add tests for stylesheets and atrules (#111)

Author: bartveneman

src/analyzer/atrules/fontfaces.js

@@ -2,20 +2,20 @@ const uniquer = require('../../utils/uniquer')
 
 module.exports = atRules => {
   const all = atRules
-    .filter(rule => rule.type === 'font-face')
-    .map(rule => rule.descriptors)
+    .filter(({type}) => type === 'font-face')
+    .map(({descriptors}) => descriptors)
 
   // Tricky bit: uniqueness will be based on the `src` of the @font-face
-  const unique = uniquer(
-    all.map(ff => ff.src)
-  ).unique.map(item => {
-    // Once we have a list of unique @font-faces,
-    // we'll map it back to the original values again
-    return {
-      count: item.count,
-      value: all.find(ff => ff.src === item.value)
+  const unique = uniquer(all.map(({src}) => src)).unique.map(
+    ({count, value}) => {
+      // Once we have a list of unique @font-faces,
+      // we'll map it back to the original values again
+      return {
+        count,
+        value: all.find(({src}) => src === value)
+      }
     }
-  })
+  )
 
   return {
     total: all.length,

test/analyzer/atrules/atrules.js test/analyzer/atrules/charsets.jstest/analyzer/atrules/atrules.js renamed to test/analyzer/atrules/charsets.js

@@ -0,0 +1,65 @@
+const test = require('ava')
+const analyze = require('../../../src/analyzer/atrules/documents')
+
+const FIXTURE = [
+  {
+    type: 'document',
+    params: 'url("https://example.com")'
+  },
+  {
+    type: 'charset',
+    params: 'A'
+  },
+  {
+    type: 'document',
+    params: 'A'
+  }
+]
+
+test('it responds with the correct structure', t => [
+  t.deepEqual(analyze([]), {
+    total: 0,
+    totalUnique: 0,
+    unique: []
+  })
+])
+
+test('it counts documents', t => {
+  const {total: actual} = analyze(FIXTURE)
+
+  t.is(actual, 2)
+})
+
+test('it finds all unique documents and counts and sorts them', t => {
+  const {unique: actual} = analyze(FIXTURE)
+
+  t.deepEqual(actual, [
+    {count: 1, value: 'A'},
+    {value: 'url("https://example.com")', count: 1}
+  ])
+})
+
+test('it counts unique documents', t => {
+  const {totalUnique: actual} = analyze(FIXTURE)
+
+  t.is(actual, 2)
+})
+
+test('it does not report non-document atrules as document', t => {
+  const actual = analyze([
+    {
+      type: 'media',
+      params: 'X'
+    },
+    {
+      type: 'charset',
+      params: 'X'
+    }
+  ])
+
+  t.deepEqual(actual, {
+    total: 0,
+    totalUnique: 0,
+    unique: []
+  })
+})

test/analyzer/atrules/documents.js

@@ -0,0 +1,127 @@
+const test = require('ava')
+const analyze = require('../../../src/analyzer/atrules/fontfaces')
+
+const FIXTURE = [
+  {
+    type: 'font-face',
+    descriptors: {
+      'font-family': 'Arial',
+      src: 'url("http://path.to/arial.woff")'
+    }
+  },
+  {
+    type: 'font-face',
+    descriptors: {
+      'font-display': 'swap',
+      'font-family': 'monospace',
+      'font-stretch': 'condensed',
+      'font-style': 'italic',
+      'font-weight': 'bold',
+      'font-variant': 'no-common-ligatures proportional-nums',
+      'font-feature-settings': '"liga" 0',
+      'font-variation-settings': '"xhgt" 0.7',
+      src: 'local("Input Mono")',
+      'unicode-range': 'U+0025-00FF'
+    }
+  },
+  {
+    type: 'font-face',
+    descriptors: {
+      'font-family': '"Input Mono"',
+      src: 'local("Input Mono") url("path/to/input_mono.ttf")'
+    }
+  },
+  {
+    type: 'font-face',
+    descriptors: {
+      'font-family': 'MyHelvetica',
+      src:
+        'local("Helvetica Neue Bold"), local("HelveticaNeue-Bold"), url(MgOpenModernaBold.ttf)',
+      'font-weight': 'bold'
+    }
+  }
+]
+
+test('it responds with the correct structure', t => [
+  t.deepEqual(analyze([]), {
+    total: 0,
+    totalUnique: 0,
+    unique: []
+  })
+])
+
+test('it counts @font-faces', t => {
+  const {total: actual} = analyze(FIXTURE)
+
+  t.is(actual, 4)
+})
+
+test('it finds all unique @font-faces and counts and sorts them', t => {
+  const {unique: actual} = analyze(FIXTURE)
+
+  t.deepEqual(actual, [
+    {
+      count: 1,
+      value: {
+        'font-family': 'MyHelvetica',
+        src:
+          'local("Helvetica Neue Bold"), local("HelveticaNeue-Bold"), url(MgOpenModernaBold.ttf)',
+        'font-weight': 'bold'
+      }
+    },
+    {
+      count: 1,
+      value: {
+        'font-display': 'swap',
+        'font-family': 'monospace',
+        'font-stretch': 'condensed',
+        'font-style': 'italic',
+        'font-weight': 'bold',
+        'font-variant': 'no-common-ligatures proportional-nums',
+        'font-feature-settings': '"liga" 0',
+        'font-variation-settings': '"xhgt" 0.7',
+        src: 'local("Input Mono")',
+        'unicode-range': 'U+0025-00FF'
+      }
+    },
+    {
+      count: 1,
+      value: {
+        'font-family': '"Input Mono"',
+        src: 'local("Input Mono") url("path/to/input_mono.ttf")'
+      }
+    },
+    {
+      count: 1,
+      value: {
+        'font-family': 'Arial',
+        src: 'url("http://path.to/arial.woff")'
+      }
+    }
+  ])
+})
+
+test('it counts unique @font-faces', t => {
+  const {totalUnique: actual} = analyze(FIXTURE)
+
+  t.is(actual, 4)
+})
+
+test('it does not report non-font-face atrules as @font-face', t => {
+  const actual = analyze([
+    {
+      type: 'media',
+      params: 'X'
+    },
+    {
+      type: 'document',
+      params: 'X'
+    }
+  ])
+
+  t.deepEqual(actual, {
+    total: 0,
+    totalUnique: 0,
+    unique: []
+  })
+})