it('resolves via a custom resolver with interface version 2', function () {
const testContext = utils.testContext({ 'import/resolver': './foo-bar-resolver-v2' })
const testContextReports = []
testContext.report = function (reportInfo) {
testContextReports.push(reportInfo)
}
expect(resolve( '../files/foo'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('foo.js') } })
)).to.equal(utils.testFilePath('./bar.jsx'))
testContextReports.length = 0
expect(resolve( '../files/exception'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('exception.js') } })
)).to.equal(undefined)
expect(testContextReports[0]).to.be.an('object')
expect(testContextReports[0].message).to.equal('Resolve error: foo-bar-resolver-v2 resolve test exception')
expect(testContextReports[0].loc).to.eql({ line: 1, column: 0 })
testContextReports.length = 0
expect(resolve( '../files/not-found'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('not-found.js') } })
)).to.equal(undefined)
expect(testContextReports.length).to.equal(0)
})
it('resolves via a custom resolver with interface version 1 assumed if not specified', function () {
const testContext = utils.testContext({ 'import/resolver': './foo-bar-resolver-no-version' })
expect(resolve( '../files/foo'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('foo.js') } })
)).to.equal(utils.testFilePath('./bar.jsx'))
expect(resolve( '../files/exception'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('exception.js') } })
)).to.equal(undefined)
expect(resolve( '../files/not-found'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('not-found.js') } })
)).to.equal(undefined)
})
it('respects import/resolver as array of objects', function () {
const testContext = utils.testContext({ 'import/resolver': [ { './foo-bar-resolver-v2': {} }, { './foo-bar-resolver-v1': {} } ] })
expect(resolve( '../files/foo'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('foo.js') } })
)).to.equal(utils.testFilePath('./bar.jsx'))
})
it('respects import/resolve extensions', function () {
const testContext = utils.testContext({ 'import/resolve': { 'extensions': ['.jsx'] }})
expect(resolve( './jsx/MyCoolComponent'
, testContext
)).to.equal(utils.testFilePath('./jsx/MyCoolComponent.jsx'))
})
function isImportingSelf(context, node, requireName) {
const filePath = context.getFilename()
// If the input is from stdin, this test can't fail
if (filePath !== '<text>' && filePath === resolve(requireName, context)) {
context.report({
node,
message: 'Module imports itself.',
})
}
}
'ImportDeclaration': function (n) {
// resolved path will cover aliased duplicates
const resolvedPath = resolve(n.source.value, context) || n.source.value
const importMap = n.importKind === 'type' ? typesImported : imported
if (importMap.has(resolvedPath)) {
importMap.get(resolvedPath).add(n.source)
} else {
importMap.set(resolvedPath, new Set([n.source]))
}
},
it('reports invalid import/resolver config', function () {
const testContext = utils.testContext({ 'import/resolver': 123.456 })
const testContextReports = []
testContext.report = function (reportInfo) {
testContextReports.push(reportInfo)
}
testContextReports.length = 0
expect(resolve( '../files/foo'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('foo.js') } })
)).to.equal(undefined)
expect(testContextReports[0]).to.be.an('object')
expect(testContextReports[0].message).to.equal('Resolve error: invalid resolver config')
expect(testContextReports[0].loc).to.eql({ line: 1, column: 0 })
})
it('reports load exception in a user resolver', function () {
const testContext = utils.testContext({ 'import/resolver': './load-error-resolver' })
const testContextReports = []
testContext.report = function (reportInfo) {
testContextReports.push(reportInfo)
}
expect(resolve( '../files/exception'
, Object.assign({}, testContext, { getFilename: function () { return utils.getFilename('exception.js') } })
)).to.equal(undefined)
expect(testContextReports[0]).to.be.an('object')
expect(testContextReports[0].message).to.equal('Resolve error: TEST ERROR')
expect(testContextReports[0].loc).to.eql({ line: 1, column: 0 })
})
function checkSourceValue(source) {
const shouldCheckCase = !CASE_SENSITIVE_FS &&
(!context.options[0] || context.options[0].caseSensitive !== false)
const resolvedPath = resolve(source.value, context)
if (resolvedPath === undefined) {
context.report(source,
`Unable to resolve path to module '${source.value}'.`)
}
else if (shouldCheckCase) {
const cacheSettings = ModuleCache.getSettings(context.settings)
if (!fileExistsWithCaseSync(resolvedPath, cacheSettings)) {
context.report(source,
`Casing of ${source.value} does not match the underlying filesystem.`)
}
}
}
it('gets correct values after cache lifetime', function () {
expect(resolve(original, context)).not.to.exist
expect(resolve(changed, context)).to.exist
})
it(`lifetime: ${inf} still gets cached values after ~1s`, function () {
expect(resolve(original, infiniteContext), original).to.exist
})
it('gets updated values immediately', function () {
// get cached values initially
expect(resolve(changed, context)).to.exist
})
it('gets cached values within cache lifetime', function () {
// get cached values initially
expect(resolve(original, context)).to.exist
})
infiniteContexts.forEach(([,c]) => {
expect(resolve(original, c)).to.exist
})
before('sanity check', function () {
expect(resolve(original, context)).to.exist
expect(resolve(changed, context)).not.to.exist
})
before('resolve', function () {
file = resolve(
// Note the case difference 'MyUncoolComponent' vs 'MyUnCoolComponent'
'./jsx/MyUncoolComponent', testContext)
})