test: init

src/pages/string/split/index.tsx

@@ -9,10 +9,9 @@ import ToolTextResult from '../../../components/result/ToolTextResult';
 import { Field, Formik, FormikProps, useFormikContext } from 'formik';
 import * as Yup from 'yup';
 import ToolOptions from '../../../components/ToolOptions';
-import { splitIntoChunks, splitTextByLength } from './service';
+import { compute, SplitOperatorType } from './service';
 import { CustomSnackBarContext } from '../../../contexts/CustomSnackBarContext';
 
-type SplitOperatorType = 'symbol' | 'regex' | 'length' | 'chunks';
 const initialValues = {
   splitSeparatorType: 'symbol' as SplitOperatorType,
   symbolValue: ' ',
@@ -160,24 +159,20 @@ export default function SplitText() {
           regexValue,
           lengthValue
         } = values;
-        let splitText;
-        switch (splitSeparatorType) {
-          case 'symbol':
-            splitText = input.split(symbolValue);
-            break;
-          case 'regex':
-            splitText = input.split(new RegExp(regexValue));
-            break;
-          case 'length':
-            splitText = splitTextByLength(input, Number(lengthValue));
-            break;
-          case 'chunks':
-            splitText = splitIntoChunks(input, Number(chunksValue)).map(
-              (chunk) => `${charBeforeChunk}${chunk}${charAfterChunk}`
-            );
-        }
-        const res = splitText.join(outputSeparator);
-        setResult(res);
+
+        setResult(
+          compute(
+            splitSeparatorType,
+            input,
+            symbolValue,
+            regexValue,
+            Number(lengthValue),
+            Number(chunksValue),
+            charBeforeChunk,
+            charAfterChunk,
+            outputSeparator
+          )
+        );
       } catch (exception: unknown) {
         if (exception instanceof Error)
           showSnackBar(exception.message, 'error');

src/pages/string/split/service.ts

@@ -1,4 +1,6 @@
-export function splitTextByLength(text: string, length: number) {
+export type SplitOperatorType = 'symbol' | 'regex' | 'length' | 'chunks';
+
+function splitTextByLength(text: string, length: number) {
   if (length <= 0) throw new Error('Length must be a positive number');
   const result: string[] = [];
   for (let i = 0; i < text.length; i += length) {
@@ -7,7 +9,7 @@ export function splitTextByLength(text: string, length: number) {
   return result;
 }
 
-export function splitIntoChunks(text: string, numChunks: number) {
+function splitIntoChunks(text: string, numChunks: number) {
   if (numChunks <= 0)
     throw new Error('Number of chunks must be a positive number');
   const totalLength = text.length;
@@ -31,3 +33,33 @@ export function splitIntoChunks(text: string, numChunks: number) {
 
   return result;
 }
+
+export function compute(
+  splitSeparatorType: SplitOperatorType,
+  input: string,
+  symbolValue: string,
+  regexValue: string,
+  lengthValue: number,
+  chunksValue: number,
+  charBeforeChunk: string,
+  charAfterChunk: string,
+  outputSeparator: string
+) {
+  let splitText;
+  switch (splitSeparatorType) {
+    case 'symbol':
+      splitText = input.split(symbolValue);
+      break;
+    case 'regex':
+      splitText = input.split(new RegExp(regexValue));
+      break;
+    case 'length':
+      splitText = splitTextByLength(input, lengthValue);
+      break;
+    case 'chunks':
+      splitText = splitIntoChunks(input, chunksValue).map(
+        (chunk) => `${charBeforeChunk}${chunk}${charAfterChunk}`
+      );
+  }
+  return splitText.join(outputSeparator);
+}

src/pages/string/split/string-split.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { compute } from './service';
+
+describe('compute function', () => {
+  it('should split by symbol', () => {
+    const result = compute('symbol', 'hello world', ' ', '', 0, 0, '', '', ',');
+    expect(result).toBe('hello,world');
+  });
+
+  it('should split by regex', () => {
+    const result = compute(
+      'regex',
+      'hello1world2again',
+      '',
+      '\\d',
+      0,
+      0,
+      '',
+      '',
+      ','
+    );
+    expect(result).toBe('hello,world,again');
+  });
+
+  it('should split by length', () => {
+    const result = compute('length', 'helloworld', '', '', 3, 0, '', '', ',');
+    expect(result).toBe('hel,low,orl,d');
+  });
+
+  it('should split into chunks', () => {
+    const result = compute(
+      'chunks',
+      'helloworldagain',
+      '',
+      '',
+      0,
+      3,
+      '[',
+      ']',
+      ','
+    );
+    expect(result).toBe('[hello],[world],[again]');
+  });
+
+  it('should handle empty input', () => {
+    const result = compute('symbol', '', ' ', '', 0, 0, '', '', ',');
+    expect(result).toBe('');
+  });
+
+  it('should handle length greater than text length', () => {
+    const result = compute('length', 'hi', '', '', 5, 0, '', '', ',');
+    expect(result).toBe('hi');
+  });
+
+  it('should handle chunks greater than text length', () => {
+    expect(() => {
+      compute('chunks', 'hi', '', '', 0, 5, '', '', ',');
+    }).toThrow('Text length must be at least as long as the number of chunks');
+  });
+
+  it('should handle invalid length', () => {
+    expect(() => {
+      compute('length', 'hello', '', '', -1, 0, '', '', ',');
+    }).toThrow('Length must be a positive number');
+  });
+
+  it('should handle invalid chunks', () => {
+    expect(() => {
+      compute('chunks', 'hello', '', '', 0, 0, '', '', ',');
+    }).toThrow('Number of chunks must be a positive number');
+  });
+});