@onurege3467/zerohelper 6.1.0 → 7.0.0

package/test copy.js

@@ -0,0 +1,144 @@
+const path = require('path');
+const createDatabase = require('./database');
+const helpers = require('./functions');
+const { setInterval } = require('timers');
+
+const mysqlConfig = {
+  adapter: 'mysql',
+  config: {
+    host: process.env.MYSQL_HOST || 'localhost',
+    user: process.env.MYSQL_USER || 'root',
+    password: process.env.MYSQL_PASSWORD || '',
+    database: process.env.MYSQL_DATABASE || 'test_db_zerohelper',
+    cache: {
+      max: 100,
+      ttl: 1000 * 10,
+      updateAgeOnGet: true,
+    },
+  },
+};
+// Absurd configurations for testing edge cases
+async function runDatabaseTests() {
+  console.log('Starting database tests...');
+
+  const databases = [
+    { name: 'MySQL', config: mysqlConfig },
+  ];
+
+  for (const dbInfo of databases) {
+    const { name, config } = dbInfo;
+    console.log(`\n--- Testing ${name} Database ---`);
+    let db;
+    try {
+      db = createDatabase(config);
+      console.log(`${name} database connected.`);
+
+      // Test Insert
+      const insertResult = await db.insert('users', { name: 'Test User', email: `test_${name.toLowerCase()}@example.com`, int_age: 30, bool_active: true,city: 'Test City' });
+      console.log(`${name} Insert:`, insertResult);
+      const selectResult = await db.selectOne('users', { _id: insertResult});
+      console.log(`${name} Select One:`, selectResult);
+      await db.set('users', {city:'Amkara'}, {_id: insertResult });
+
+      setInterval(async () => {
+        const updatedSelectResult = await db.selectOne('users', { _id: insertResult });
+        console.log(`${name} Select One after update:`, updatedSelectResult);
+      }, 1000);
+
+     
+
+    } catch (error) {
+      console.error(`Error testing ${name} database:`, error);
+    } finally {
+      if (db) {
+        try {
+        } catch (closeError) {
+          console.error(`Error closing ${name} database connection:`, closeError);
+        }
+      }
+    }
+  
+
+  console.log('\nAll database tests completed.');
+}
+}
+function runHelperFunctionTests() {
+  console.log('\nStarting helper function tests...');
+
+  // Random Functions
+  console.log('\n--- Testing Random Functions ---');
+  console.log('makeUniqueId:', helpers.random.makeUniqueId());
+  console.log('randomArray:', helpers.random.randomArray([1, 2, 3]));
+  console.log('randomText (5 chars):', helpers.random.randomText(5));
+  console.log('randomNumber (1-10):', helpers.random.randomNumber(1, 10));
+  console.log('randomEmoji:', helpers.random.randomEmoji());
+  console.log('randomHex:', helpers.random.randomHex());
+  console.log('randomFloat (1.0-2.0):', helpers.random.randomFloat(1.0, 2.0));
+
+  // String Functions
+  console.log('\n--- Testing String Functions ---');
+  console.log('titleCase:', helpers.string.titleCase('hello world'));
+  console.log('generateRandomString (8 chars):', helpers.string.generateRandomString(8));
+
+  // Array Functions
+  console.log('\n--- Testing Array Functions ---');
+  console.log('shuffleArray:', helpers.array.shuffleArray([1, 2, 3, 4, 5]));
+  console.log('flattenArray:', helpers.array.flattenArray([1, [2, [3]], 4]));
+  console.log('removeFalsyValues:', helpers.array.removeFalsyValues([0, 1, false, '', null, undefined, 2]));
+  const groupByData = [
+    { type: 'A', value: 1 },
+    { type: 'B', value: 2 },
+    { type: 'A', value: 3 },
+  ];
+  console.log('groupBy:', helpers.array.groupBy(groupByData, 'type'));
+  const pluckData = [
+    { name: 'Alice', age: 30 },
+    { name: 'Bob', age: 24 },
+  ];
+  console.log('pluck (name):', helpers.array.pluck(pluckData, 'name'));
+  const sortByData = [
+    { age: 30 },
+    { age: 20 },
+    { age: 40 },
+  ];
+  console.log('sortBy (age):', helpers.array.sortBy(sortByData, 'age'));
+
+  // Object Functions
+  console.log('\n--- Testing Object Functions ---');
+  const filterObjectData = { a: 1, b: 2, c: 3 };
+  console.log('filterObjectByKey:', helpers.object.filterObjectByKey(filterObjectData, ['a', 'c']));
+  const deepMergeData1 = { a: 1, b: { c: 2 } };
+  const deepMergeData2 = { b: { d: 3 }, e: 4 };
+  console.log('deepMerge:', helpers.object.deepMerge(deepMergeData1, deepMergeData2));
+
+  // Crypto Functions
+  console.log('\n--- Testing Crypto Functions ---');
+  const secret = 'mySuperSecretKey';
+  const textToEncrypt = 'Hello Crypto!';
+  const encryptedResult = helpers.crypto.encryptText(textToEncrypt, secret);
+  const encryptedText = encryptedResult.encryptedText;
+  const iv = encryptedResult.iv;
+  console.log('encryptText:', encryptedText);
+  console.log('decryptText:', helpers.crypto.decryptText(encryptedText, secret, iv));
+  const password = 'mySecurePassword';
+  const hashedPassword = helpers.crypto.hashPassword(password);
+  console.log('hashPassword:', hashedPassword);
+  console.log('verifyPassword (true):', helpers.crypto.verifyPassword(password, hashedPassword));
+  console.log('verifyPassword (false):', helpers.crypto.verifyPassword('wrongPassword', hashedPassword));
+  const jwtPayload = { userId: 123, username: 'testuser' };
+  const jwtToken = helpers.crypto.generateJWT(jwtPayload, secret);
+  console.log('generateJWT:', jwtToken);
+  console.log('verifyJWT:', helpers.crypto.verifyJWT(jwtToken, secret));
+
+  // Math Functions
+  console.log('\n--- Testing Math Functions ---');
+  console.log('mean:', helpers.math.mean([1, 2, 3, 4, 5]));
+  console.log('isPrime (7):', helpers.math.isPrime(7));
+  console.log('isPrime (10):', helpers.math.isPrime(10));
+}
+
+async function main() {
+  await runDatabaseTests();
+}
+
+main();

package/test.js

@@ -20,7 +20,7 @@ const mysqlConfig = {
 const mongoConfig = {
   adapter: 'mongodb',
   config: {
-    url: process.env.MONGODB_URL || 'mongodb://localhost:27017/test',
+    url: process.env.MONGODB_URL || 'MONGODB_URL',
     database: process.env.MONGODB_DATABASE || 'test_mongo_db_zerohelper',
     cache: {
       max: 100,
@@ -56,61 +56,29 @@ const cachedSqliteConfig = {
   },
 };
 
-// Absurd configurations for testing edge cases
-const mysqlAbsurdConfig = {
-  adapter: 'mysql',
-  config: {
-    host: process.env.MYSQL_HOST || 'localhost',
-    user: process.env.MYSQL_USER || 'root',
-    password: process.env.MYSQL_PASSWORD || '',
-    database: 'very_long_and_absurd_database_name_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz',
-    cache: {
-      max: 10,
-      ttl: 1000 * 5,
-    },
-  },
-};
-
-const mongoAbsurdConfig = {
-  adapter: 'mongodb',
-  config: {
-    url: process.env.MONGODB_URL || 'mongodb://localhost:27017/test',
-    database: 'very_long_and_absurd_mongodb_database_name_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz',
-    cache: {
-      max: 10,
-      ttl: 1000 * 5,
-    },
-  },
-};
-
-const jsonAbsurdConfig = {
-  adapter: 'json',
-  config: {
-    filePath: path.join(__dirname, 'data', 'very_long_and_absurd_json_file_path_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz.json'),
-    cache: {
-      max: 10,
-      ttl: 1000 * 5,
-    },
-  },
-};
-
-const sqliteAbsurdConfig = {
-  adapter: 'sqlite',
+const pgConfig = {
+  adapter: 'postgres',
   config: {
-    filePath: path.join(__dirname, 'data', 'very_long_and_absurd_sqlite_file_path_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz.sqlite'),
+    host: process.env.PG_HOST || 'localhost',
+    user: process.env.PG_USER || 'postgres',
+    password: process.env.PG_PASSWORD || '',
+    database: process.env.PG_DATABASE || 'test_db_zerohelper_pg',
     cache: {
-      max: 10,
-      ttl: 1000 * 5,
+      max: 100,
+      ttl: 1000 * 10,
+      updateAgeOnGet: true,
     },
   },
 };
 
+// Absurd configurations for testing edge cases
 async function runDatabaseTests() {
   console.log('Starting database tests...');
 
   const databases = [
     { name: 'MySQL', config: mysqlConfig },
     { name: 'MongoDB', config: mongoConfig },
+    { name: 'PostgreSQL', config: pgConfig },
     { name: 'JSON', config: jsonConfig },
     { name: 'SQLite', config: sqliteConfig },
   ];
@@ -124,7 +92,7 @@ async function runDatabaseTests() {
       console.log(`${name} database connected.`);
 
       // Test Insert
-      const insertResult = await db.insert('users', { name: 'Test User', email: `test_${name.toLowerCase()}@example.com`, age: 30 });
+      const insertResult = await db.insert('users', { name: 'Test User', email: `test_${name.toLowerCase()}@example.com`, int_age: 30, bool_active: true });
       console.log(`${name} Insert:`, insertResult);
 
       // Test SelectOne
@@ -133,7 +101,7 @@ async function runDatabaseTests() {
 
       // Test Update
       if (user) {
-        const updateResult = await db.update('users', { age: 31 }, { name: 'Test User' });
+        const updateResult = await db.update('users', { int_age: 31 }, { name: 'Test User' });
         console.log(`${name} Update:`, updateResult);
       }
 
@@ -207,66 +175,6 @@ async function runDatabaseTests() {
     }
   }
 
-  // --- Testing Absurd Database Names/Tables/Columns ---
-  console.log('\n--- Testing Absurd Database Names/Tables/Columns ---');
-  const absurdDatabases = [
-    { name: 'MySQL Absurd', config: mysqlAbsurdConfig },
-    { name: 'MongoDB Absurd', config: mongoAbsurdConfig },
-    { name: 'JSON Absurd', config: jsonAbsurdConfig },
-    { name: 'SQLite Absurd', config: sqliteAbsurdConfig },
-  ];
-
-  for (const dbInfo of absurdDatabases) {
-    const { name, config } = dbInfo;
-    console.log(`\n--- Testing ${name} ---`);
-    let db;
-    try {
-      db = createDatabase(config);
-      console.log(`${name} database connected.`);
-
-      const absurdTableName = 'very_long_and_absurd_table_name_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz';
-      const absurdColumnName = 'very_long_and_absurd_column_name_for_testing_purposes_1234567890_abcdefghijklmnopqrstuvwxyz';
-      const absurdValue = 'Absurd Value with !@#$%^&*()-+=';
-
-      // Test Insert with absurd names
-      const insertResult = await db.insert(absurdTableName, { [absurdColumnName]: absurdValue, 'another_col': 'some_data' });
-      console.log(`${name} Insert:`, insertResult);
-
-      // Test SelectOne with absurd names
-      const data = await db.selectOne(absurdTableName, { [absurdColumnName]: absurdValue });
-      console.log(`${name} SelectOne:`, data);
-
-      // Test Update with absurd names
-      if (data) {
-        const updateResult = await db.update(absurdTableName, { 'updated_col': 'updated_data' }, { [absurdColumnName]: absurdValue });
-        console.log(`${name} Update:`, updateResult);
-      }
-
-      // Test Select (all) with absurd names
-      const allData = await db.select(absurdTableName);
-      console.log(`${name} Select All:`, allData);
-
-      // Test Set (upsert) with absurd names
-      const setResult = await db.set(absurdTableName, { 'set_col': 'set_data' }, { [absurdColumnName]: absurdValue });
-      console.log(`${name} Set (upsert):`, setResult);
-
-      // Test Delete with absurd names
-      const deleteResult = await db.delete(absurdTableName, { [absurdColumnName]: absurdValue });
-      console.log(`${name} Delete:`, deleteResult);
-
-    } catch (error) {
-      console.error(`Error testing ${name} database:`, error);
-    } finally {
-      if (db) {
-        try {
-          await db.close();
-          console.log(`${name} database connection closed.`);
-        } catch (closeError) {
-          console.error(`Error closing ${name} database connection:`, closeError);
-        }
-      }
-    }
-  }
 
   console.log('\nAll database tests completed.');
 }
@@ -348,7 +256,6 @@ function runHelperFunctionTests() {
 
 async function main() {
   await runDatabaseTests();
-  runHelperFunctionTests();
 }
 
 main();