Fix localhost URL support and refector tests

* Fixes #13 (http://localhost URLs not working)
* Refactors tests by breaking up large test file

Author: iaincollins

__tests__/input-type-detection.js

@@ -0,0 +1,74 @@
+// Test dectection of different types of input
+const fs = require('fs')
+const fetch = require('node-fetch')
+
+const {
+  structuredDataTest,
+  structuredDataTestUrl,
+  structuredDataTestHtml
+} = require('../index')
+const presets = require('../presets')
+
+const testFile = '__tests__/fixtures/example.html'
+const html = fs.readFileSync(testFile)
+
+describe('Input type detection', () => {
+  beforeAll(async () => {
+    // Mock fetch request
+    fetch.resetMocks()
+    fetch.mockResponse(html);
+  })
+
+  afterAll(() => {
+    fetch.resetMocks()
+  })
+
+  test('should auto-detect when input is a buffer', async () => {
+    const result = await new Promise((resolve) => {
+      fs.readFile(testFile, async (err, buffer) => {
+        return resolve(await structuredDataTest(buffer, { presets: [ presets.Google ]}))
+      })
+    })
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })
+
+  test('should auto-detect when input is a readable stream', async () => {
+    const buffer = fs.createReadStream(testFile)
+    const result = await structuredDataTest(buffer, { presets: [ presets.Google ]})
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })
+
+  test('should auto-detect when input is an HTTP URL', async () => {
+    const result = await structuredDataTest('http://example.com', { presets: [ presets.Google ]})
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })
+
+  test('should auto-detect when input is an HTTPS URL', async () => {
+    const result = await structuredDataTest('https://example.com', { presets: [ presets.Google ]})
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })  
+
+  test('should work when explicitly invoked with HTML', async () => {
+    const result = await structuredDataTestHtml(html, { presets: [ presets.Google ]})
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })
+
+  test('should work when explicitly invoked with a URL', async () => {
+    const result = await structuredDataTestUrl('https://example.com', { presets: [ presets.Google ]})
+    expect(result.passed.length).toBeGreaterThan(10)
+    expect(result.failed.length).toEqual(0)
+  })
+
+  test('should support http://localhost URLs', async () => {
+    // Tests fix for bug where http://localhost URLs did not always work
+    // https://github.com/glitchdigital/structured-data-testing-tool/issues/13
+    const result = await structuredDataTest('http://localhost', { presets: [ presets.Google ] })
+    expect(result.passed.length).toBeGreaterThan(1)
+    expect(result.failed.length).toEqual(0)
+  })
+})

__tests__/index.js renamed to __tests__/parsing-and-options.js

@@ -1,101 +1,37 @@
-
 const fs = require('fs')
 const fetch = require('node-fetch')
+
 const {
-  _structuredDataTest,
   structuredDataTest,
-  structuredDataTestUrl,
-  structuredDataTestHtml
+  structuredDataTestUrl
 } = require('../index')
 const presets = require('../presets')
 
-
-// @FIXME Split out this single catch-all example file to test multiple scenarios separately
 const testFile = '__tests__/fixtures/example.html'
 const html = fs.readFileSync(testFile)
 
+// Used to hold the test result that is used across these tests
 let structuredDataTestResult = null
 
-describe('Structured Data parsing', () => {
+describe('Parsing and options', () => {
   beforeAll(async () => {
     // Mock fetch request
     fetch.resetMocks()
     fetch.mockResponse(html);
 
-    // Current test uses single example file
+    // @TODO This test uses a single fixture for all tests
     // Ideally there would be multiple different fixtures that more robustly
-    // test different scenarios, but this is is a practical approach that
-    // improves coverage easily for now with minimal effort
+    // test different scenarios, but this is is a practical approach that gives
+    // good coverage with minimal effort.
     await structuredDataTest(html, { presets: [ presets.Google, presets.Twitter ]})
-    .then(response => {
-      structuredDataTestResult = response
-    })
-    .catch(err => {
-      structuredDataTestResult = err.res
-    })
+    .then(response => { structuredDataTestResult = response })
+    .catch(err => { structuredDataTestResult = err.res })
   })
 
   afterAll(() => {
     fetch.resetMocks()
   })
 
-  test('should auto-detect and return structured data schemas found', async () => {
-    expect(structuredDataTestResult.schemas.length).toEqual(4)
-    expect(structuredDataTestResult.failed.length).toEqual(0)
-  })
-
-  test('should auto-detect when input is HTML and validate all schemas found', async () => {
-    expect(structuredDataTestResult.passed.length).toBeGreaterThan(10)
-    expect(structuredDataTestResult.failed.length).toEqual(0)
-  })
-  
-  test('should auto-detect when input is a string', async () => {
-    const result = await structuredDataTest(html.toString(), { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
-  test('should auto-detect when input is a buffer', async () => {
-    const result = await new Promise((resolve) => {
-      fs.readFile(testFile, async (err, buffer) => {
-        return resolve(await structuredDataTest(buffer, { presets: [ presets.Google ]}))
-      })
-    })
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
-  test('should auto-detect when input is a readable stream', async () => {
-    const buffer = fs.createReadStream(testFile)
-    const result = await structuredDataTest(buffer, { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
-  test('should auto-detect when input is an HTTP URL', async () => {
-    const result = await structuredDataTest('http://example.com', { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
-  test('should auto-detect when input is an HTTPS URL', async () => {
-    const result = await structuredDataTest('https://example.com', { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })  
-
-  test('should work when explicitly invoked with HTML', async () => {
-    const result = await structuredDataTestHtml(html, { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
-  test('should work when explicitly invoked with a URL', async () => {
-    const result = await structuredDataTestUrl('https://example.com', { presets: [ presets.Google ]})
-    expect(result.passed.length).toBeGreaterThan(10)
-    expect(result.failed.length).toEqual(0)
-  })
-
   // @FIXME This test covers too much at once, should split out error handling checks
   // @FIXME This test also tests ever preset for coverage - that should move to the presets test file
   test('should validate all structured data schemas found as well as any presets specified and handle errors correctly', async () => {

__tests__/presets.js

@@ -1,5 +1,6 @@
 
 const fs = require('fs')
+
 const { structuredDataTest } = require('../index')
 const presets = require('../presets')
 

index.js

@@ -431,7 +431,7 @@ const structuredDataTest = async (input, options) => {
   if (typeof(input) === 'string') {
     // If is a string…
     // Assumed to be URL or HTML
-    if (validator.isURL(input)) {
+    if (validator.isURL(input, { require_tld: false })) {
       // @TODO Improve URL error handling
       const url = input
       const res = await fetch(url)

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "structured-data-testing-tool",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "A library and command line tool to help test for Structured Data.",
   "repository": "https://github.com/glitchdigital/structured-data-testing-tool",
   "main": "index.js",