From 1ed0610347c3849dc474e833894b77e6c97f74c3 Mon Sep 17 00:00:00 2001
From: nikkeyl <131481562+nikkeyl@users.noreply.github.com>
Date: Thu, 16 Jan 2025 23:28:45 +0300
Subject: [PATCH] feat: specs

---
 specs/font-file-name.spec.ts             |  40 +++++++
 specs/selectors.spec.ts                  | 133 ++++++++++++++++-------
 src/validators/font-file-name.ts         |   4 +-
 src/validators/{ => helpers}/italic.ts   |   0
 src/validators/{ => helpers}/variable.ts |   0
 5 files changed, 138 insertions(+), 39 deletions(-)
 create mode 100644 specs/font-file-name.spec.ts
 rename src/validators/{ => helpers}/italic.ts (100%)
 rename src/validators/{ => helpers}/variable.ts (100%)

diff --git a/specs/font-file-name.spec.ts b/specs/font-file-name.spec.ts
new file mode 100644
index 0000000..97a3563
--- /dev/null
+++ b/specs/font-file-name.spec.ts
@@ -0,0 +1,40 @@
+import { describe, expect, test as spec } from 'bun:test';
+import { FONT_FILE_NAME_REGEX } from '#src/index.ts';
+
+describe('FONT_FILE_NAME_REGEX', () => {
+  const validTestCases = [
+    'Roboto-Bold.otf',
+    'OpenSans-Light.ttf',
+    'Montserrat-ExtraBold.woff',
+    'Lato-Regular.woff2',
+    'Roboto-BoldItalic.otf',
+    'OpenSans-LightVariable.ttf',
+    'Montserrat-ExtraBoldItalicVariable.woff',
+    'Lato-RegularVariable.woff2',
+  ];
+
+  validTestCases.forEach((testCase) => {
+    spec(`should match valid font file name: ${testCase}`, () => {
+      expect(testCase).toMatch(FONT_FILE_NAME_REGEX);
+    });
+  });
+
+  const invalidTestCases = [
+    'Roboto-Bold',
+    'OpenSans-Light.pdf',
+    'Montserrat-ExtraBoldItalic',
+    'Lato-RegularVariable',
+    'Roboto-Bold.otf.ttf',
+    'OpenSans-Light.ttf.woff',
+    'Montserrat-ExtraBoldItalicVariable',
+    'Lato-RegularVariable.woff2.ttf',
+    'Roboto-Bold.otf ',
+    ' OpenSans-Light.ttf',
+  ];
+
+  invalidTestCases.forEach((testCase) => {
+    spec(`should not match invalid font file name: ${testCase}`, () => {
+      expect(testCase).not.toMatch(FONT_FILE_NAME_REGEX);
+    });
+  });
+});
diff --git a/specs/selectors.spec.ts b/specs/selectors.spec.ts
index 354d956..58716d2 100644
--- a/specs/selectors.spec.ts
+++ b/specs/selectors.spec.ts
@@ -1,77 +1,136 @@
 import { describe, expect, test as spec } from 'bun:test';
 
-import { NESTED_ATTRIBUTE_REGEX, NESTED_CLASS_REGEX } from '#src/index.ts';
+import {
+  NESTED_ATTRIBUTE_REGEX,
+  NESTED_CLASS_REGEX,
+  NESTED_MODIFIER_REGEX,
+  NESTED_ELEMENT_REGEX,
+  ATTRIBUTE_REGEX,
+  CLASS_REGEX,
+  MODIFIER_REGEX,
+  ELEMENT_REGEX,
+  SIBLING_REGEX,
+  CHILD_REGEX,
+  ATTRIBUTE_SIBLING_REGEX,
+  ATTRIBUTE_CHILD_REGEX,
+  CLASS_SIBLING_REGEX,
+  CLASS_CHILD_REGEX,
+  NESTED_ATTRIBUTE_SIBLING_REGEX,
+  NESTED_ATTRIBUTE_CHILD_REGEX,
+  NESTED_CLASS_SIBLING_REGEX,
+  NESTED_CLASS_CHILD_REGEX,
+} from '#src/index.ts';
 
 describe('Nested Selectors Regex', async () => {
-  spec('should &[attribute]', async () => {
+  spec('should match &[attribute]', async () => {
     expect('&[attribute]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute] {}', async () => {
-    expect('&[attribute] {}').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
-  });
-
-  spec('should &[attribute=value]', async () => {
+  spec('should match &[attribute=value]', async () => {
     expect('&[attribute=value]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute*=value]', async () => {
+  spec('should match &[attribute*=value]', async () => {
     expect('&[attribute*=value]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute=value] {}', async () => {
-    expect('&[attribute=value] {}').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match &[attribute="value"]', async () => {
+    expect('&[attribute="value"]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute*=value] {}', async () => {
-    expect('&[attribute*=value] {}').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match &[attribute*="value"]', async () => {
+    expect('&[attribute*="value"]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec("&[attribute='value']", async () => {
+  spec("should match &[attribute='value']", async () => {
     expect("&[attribute='value']").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute*="value"]', async () => {
-    expect('&[attribute*="value"]').toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec("should match &[attribute*='value']", async () => {
+    expect("&[attribute*='value']").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
   });
 
-  spec('should &[attribute="value"] {}', async () => {
-    expect("&[attribute='value'] {}").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match &.class', async () => {
+    expect('&.class').toMatch(new RegExp(NESTED_CLASS_REGEX));
   });
 
-  spec('should &[attribute*="value"] {}', async () => {
-    expect("&[attribute*='value'] {}").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match &--modifier', async () => {
+    expect('&--modifier').toMatch(new RegExp(NESTED_MODIFIER_REGEX));
   });
 
-  spec("&[attribute='value']", async () => {
-    expect("&[attribute='value']").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match &__element', async () => {
+    expect('&__element').toMatch(new RegExp(NESTED_ELEMENT_REGEX));
   });
 
-  spec("&[attribute*='value']", async () => {
-    expect("&[attribute*='value']").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match [attribute]', async () => {
+    expect('[attribute]').toMatch(new RegExp(ATTRIBUTE_REGEX));
   });
 
-  spec("&[attribute='value'] {}", async () => {
-    expect("&[attribute='value'] {}").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match [attribute=value]', async () => {
+    expect('[attribute=value]').toMatch(new RegExp(ATTRIBUTE_REGEX));
   });
 
-  spec("&[attribute*='value'] {}", async () => {
-    expect("&[attribute*='value'] {}").toMatch(new RegExp(NESTED_ATTRIBUTE_REGEX));
+  spec('should match [attribute*=value]', async () => {
+    expect('[attribute*=value]').toMatch(new RegExp(ATTRIBUTE_REGEX));
   });
 
-  spec('should &.class', async () => {
-    expect('&.class').toMatch(new RegExp(NESTED_CLASS_REGEX));
+  spec('should match .class', async () => {
+    expect('.class').toMatch(new RegExp(CLASS_REGEX));
   });
 
-  spec('should &.class {}', async () => {
-    expect('&.class {}').toMatch(new RegExp(NESTED_CLASS_REGEX));
+  spec('should match --modifier', async () => {
+    expect('--modifier').toMatch(new RegExp(MODIFIER_REGEX));
   });
 
-  // spec('should &--modifier', async () => {
-  //   expect('&--modifier').toMatch(new RegExp(MODIFIER_REGEX));
-  // });
+  spec('should match __element', async () => {
+    expect('__element').toMatch(new RegExp(ELEMENT_REGEX));
+  });
+
+  spec('should match sibling selector', async () => {
+    expect('+ p').toMatch(new RegExp(SIBLING_REGEX));
+  });
+
+  spec('should match child selector', async () => {
+    expect('> p').toMatch(new RegExp(CHILD_REGEX));
+  });
+
+  spec('should match sibling selector', async () => {
+    expect('div + p').toMatch(new RegExp(SIBLING_REGEX));
+  });
 
-  // spec('should &--modifier {}', async () => {
-  //   expect('&--modifier {}').toMatch(new RegExp(MODIFIER_REGEX));
-  // });
+  spec('should match child selector', async () => {
+    expect('div > p').toMatch(new RegExp(CHILD_REGEX));
+  });
+
+  spec('should match attribute sibling selector', async () => {
+    expect('[attribute] + p').toMatch(new RegExp(ATTRIBUTE_SIBLING_REGEX));
+  });
+
+  spec('should match attribute child selector', async () => {
+    expect('[attribute] > p').toMatch(new RegExp(ATTRIBUTE_CHILD_REGEX));
+  });
+
+  spec('should match class sibling selector', async () => {
+    expect('.class + p').toMatch(new RegExp(CLASS_SIBLING_REGEX));
+  });
+
+  spec('should match class child selector', async () => {
+    expect('.class > p').toMatch(new RegExp(CLASS_CHILD_REGEX));
+  });
+
+  spec('should match nested attribute sibling selector', async () => {
+    expect('&[attribute] + p').toMatch(new RegExp(NESTED_ATTRIBUTE_SIBLING_REGEX));
+  });
+
+  spec('should match nested attribute child selector', async () => {
+    expect('&[attribute] > p').toMatch(new RegExp(NESTED_ATTRIBUTE_CHILD_REGEX));
+  });
+
+  spec('should match nested class sibling selector', async () => {
+    expect('&.class + p').toMatch(new RegExp(NESTED_CLASS_SIBLING_REGEX));
+  });
+
+  spec('should match nested class child selector', async () => {
+    expect('&.class > p').toMatch(new RegExp(NESTED_CLASS_CHILD_REGEX));
+  });
 });
diff --git a/src/validators/font-file-name.ts b/src/validators/font-file-name.ts
index f32083d..d9118ba 100644
--- a/src/validators/font-file-name.ts
+++ b/src/validators/font-file-name.ts
@@ -1,5 +1,5 @@
-import { ITALIC_REGEX } from './italic.ts';
-import { VARIABLE_REGEX } from './variable.ts';
+import { ITALIC_REGEX } from './helpers/italic.ts';
+import { VARIABLE_REGEX } from './helpers/variable.ts';
 
 const LETTERS_REGEX = '[A-Z][a-z]';
 const FONT_FAMILY_REGEX = `^${LETTERS_REGEX}+(${LETTERS_REGEX}+)?`;
diff --git a/src/validators/italic.ts b/src/validators/helpers/italic.ts
similarity index 100%
rename from src/validators/italic.ts
rename to src/validators/helpers/italic.ts
diff --git a/src/validators/variable.ts b/src/validators/helpers/variable.ts
similarity index 100%
rename from src/validators/variable.ts
rename to src/validators/helpers/variable.ts