pulsar/spec/config-spec.js

2362 lines
74 KiB
JavaScript

describe('Config', () => {
let savedSettings
beforeEach(() => {
spyOn(console, 'warn')
atom.config.settingsLoaded = true
savedSettings = []
atom.config.saveCallback = function (settings) {
savedSettings.push(settings)
}
})
describe('.get(keyPath, {scope, sources, excludeSources})', () => {
it("allows a key path's value to be read", () => {
expect(atom.config.set('foo.bar.baz', 42)).toBe(true)
expect(atom.config.get('foo.bar.baz')).toBe(42)
expect(atom.config.get('foo.quux')).toBeUndefined()
})
it("returns a deep clone of the key path's value", () => {
atom.config.set('value', { array: [1, { b: 2 }, 3] })
const retrievedValue = atom.config.get('value')
retrievedValue.array[0] = 4
retrievedValue.array[1].b = 2.1
expect(atom.config.get('value')).toEqual({ array: [1, { b: 2 }, 3] })
})
it('merges defaults into the returned value if both the assigned value and the default value are objects', () => {
atom.config.setDefaults('foo.bar', { baz: 1, ok: 2 })
atom.config.set('foo.bar', { baz: 3 })
expect(atom.config.get('foo.bar')).toEqual({ baz: 3, ok: 2 })
atom.config.setDefaults('other', { baz: 1 })
atom.config.set('other', 7)
expect(atom.config.get('other')).toBe(7)
atom.config.set('bar.baz', { a: 3 })
atom.config.setDefaults('bar', { baz: 7 })
expect(atom.config.get('bar.baz')).toEqual({ a: 3 })
})
describe("when a 'sources' option is specified", () =>
it('only retrieves values from the specified sources', () => {
atom.config.set('x.y', 1, { scopeSelector: '.foo', source: 'a' })
atom.config.set('x.y', 2, { scopeSelector: '.foo', source: 'b' })
atom.config.set('x.y', 3, { scopeSelector: '.foo', source: 'c' })
atom.config.setSchema('x.y', { type: 'integer', default: 4 })
expect(
atom.config.get('x.y', { sources: ['a'], scope: ['.foo'] })
).toBe(1)
expect(
atom.config.get('x.y', { sources: ['b'], scope: ['.foo'] })
).toBe(2)
expect(
atom.config.get('x.y', { sources: ['c'], scope: ['.foo'] })
).toBe(3)
// Schema defaults never match a specific source. We could potentially add a special "schema" source.
expect(
atom.config.get('x.y', { sources: ['x'], scope: ['.foo'] })
).toBeUndefined()
expect(
atom.config.get(null, { sources: ['a'], scope: ['.foo'] }).x.y
).toBe(1)
}))
describe("when an 'excludeSources' option is specified", () =>
it('only retrieves values from the specified sources', () => {
atom.config.set('x.y', 0)
atom.config.set('x.y', 1, { scopeSelector: '.foo', source: 'a' })
atom.config.set('x.y', 2, { scopeSelector: '.foo', source: 'b' })
atom.config.set('x.y', 3, { scopeSelector: '.foo', source: 'c' })
atom.config.setSchema('x.y', { type: 'integer', default: 4 })
expect(
atom.config.get('x.y', { excludeSources: ['a'], scope: ['.foo'] })
).toBe(3)
expect(
atom.config.get('x.y', { excludeSources: ['c'], scope: ['.foo'] })
).toBe(2)
expect(
atom.config.get('x.y', {
excludeSources: ['b', 'c'],
scope: ['.foo']
})
).toBe(1)
expect(
atom.config.get('x.y', {
excludeSources: ['b', 'c', 'a'],
scope: ['.foo']
})
).toBe(0)
expect(
atom.config.get('x.y', {
excludeSources: ['b', 'c', 'a', atom.config.getUserConfigPath()],
scope: ['.foo']
})
).toBe(4)
expect(
atom.config.get('x.y', {
excludeSources: [atom.config.getUserConfigPath()]
})
).toBe(4)
}))
describe("when a 'scope' option is given", () => {
it('returns the property with the most specific scope selector', () => {
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee .string.quoted.double.coffee'
})
atom.config.set('foo.bar.baz', 22, {
scopeSelector: '.source .string.quoted.double'
})
atom.config.set('foo.bar.baz', 11, { scopeSelector: '.source' })
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string.quoted.double.coffee']
})
).toBe(42)
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.js', '.string.quoted.double.js']
})
).toBe(22)
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.js', '.variable.assignment.js']
})
).toBe(11)
expect(
atom.config.get('foo.bar.baz', { scope: ['.text'] })
).toBeUndefined()
})
it('favors the most recently added properties in the event of a specificity tie', () => {
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee .string.quoted.single'
})
atom.config.set('foo.bar.baz', 22, {
scopeSelector: '.source.coffee .string.quoted.double'
})
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string.quoted.single']
})
).toBe(42)
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string.quoted.single.double']
})
).toBe(22)
})
describe('when there are global defaults', () =>
it('falls back to the global when there is no scoped property specified', () => {
atom.config.setDefaults('foo', { hasDefault: 'ok' })
expect(
atom.config.get('foo.hasDefault', {
scope: ['.source.coffee', '.string.quoted.single']
})
).toBe('ok')
}))
describe('when package settings are added after user settings', () =>
it("returns the user's setting because the user's setting has higher priority", () => {
atom.config.set('foo.bar.baz', 100, {
scopeSelector: '.source.coffee'
})
atom.config.set('foo.bar.baz', 1, {
scopeSelector: '.source.coffee',
source: 'some-package'
})
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(100)
}))
})
})
describe('.getAll(keyPath, {scope, sources, excludeSources})', () => {
it('reads all of the values for a given key-path', () => {
expect(atom.config.set('foo', 41)).toBe(true)
expect(atom.config.set('foo', 43, { scopeSelector: '.a .b' })).toBe(true)
expect(atom.config.set('foo', 42, { scopeSelector: '.a' })).toBe(true)
expect(atom.config.set('foo', 44, { scopeSelector: '.a .b.c' })).toBe(
true
)
expect(atom.config.set('foo', -44, { scopeSelector: '.d' })).toBe(true)
expect(atom.config.getAll('foo', { scope: ['.a', '.b.c'] })).toEqual([
{ scopeSelector: '.a .b.c', value: 44 },
{ scopeSelector: '.a .b', value: 43 },
{ scopeSelector: '.a', value: 42 },
{ scopeSelector: '*', value: 41 }
])
})
it("includes the schema's default value", () => {
atom.config.setSchema('foo', { type: 'number', default: 40 })
expect(atom.config.set('foo', 43, { scopeSelector: '.a .b' })).toBe(true)
expect(atom.config.getAll('foo', { scope: ['.a', '.b.c'] })).toEqual([
{ scopeSelector: '.a .b', value: 43 },
{ scopeSelector: '*', value: 40 }
])
})
})
describe('.set(keyPath, value, {source, scopeSelector})', () => {
it("allows a key path's value to be written", () => {
expect(atom.config.set('foo.bar.baz', 42)).toBe(true)
expect(atom.config.get('foo.bar.baz')).toBe(42)
})
it("saves the user's config to disk after it stops changing", () => {
atom.config.set('foo.bar.baz', 42)
expect(savedSettings.length).toBe(0)
atom.config.set('foo.bar.baz', 43)
expect(savedSettings.length).toBe(0)
atom.config.set('foo.bar.baz', 44)
advanceClock(10)
expect(savedSettings.length).toBe(1)
})
it("does not save when a non-default 'source' is given", () => {
atom.config.set('foo.bar.baz', 42, {
source: 'some-other-source',
scopeSelector: '.a'
})
advanceClock(500)
expect(savedSettings.length).toBe(0)
})
it("does not allow a 'source' option without a 'scopeSelector'", () => {
expect(() =>
atom.config.set('foo', 1, { source: ['.source.ruby'] })
).toThrow()
})
describe('when the key-path is null', () =>
it('sets the root object', () => {
expect(atom.config.set(null, { editor: { tabLength: 6 } })).toBe(true)
expect(atom.config.get('editor.tabLength')).toBe(6)
expect(
atom.config.set(null, {
editor: { tabLength: 8, scopeSelector: ['.source.js'] }
})
).toBe(true)
expect(
atom.config.get('editor.tabLength', { scope: ['.source.js'] })
).toBe(8)
}))
describe('when the value equals the default value', () =>
it("does not store the value in the user's config", () => {
atom.config.setSchema('foo', {
type: 'object',
properties: {
same: {
type: 'number',
default: 1
},
changes: {
type: 'number',
default: 1
},
sameArray: {
type: 'array',
default: [1, 2, 3]
},
sameObject: {
type: 'object',
default: { a: 1, b: 2 }
},
null: {
type: '*',
default: null
},
undefined: {
type: '*',
default: undefined
}
}
})
expect(atom.config.settings.foo).toBeUndefined()
atom.config.set('foo.same', 1)
atom.config.set('foo.changes', 2)
atom.config.set('foo.sameArray', [1, 2, 3])
atom.config.set('foo.null', undefined)
atom.config.set('foo.undefined', null)
atom.config.set('foo.sameObject', { b: 2, a: 1 })
const userConfigPath = atom.config.getUserConfigPath()
expect(
atom.config.get('foo.same', { sources: [userConfigPath] })
).toBeUndefined()
expect(atom.config.get('foo.changes')).toBe(2)
expect(
atom.config.get('foo.changes', { sources: [userConfigPath] })
).toBe(2)
atom.config.set('foo.changes', 1)
expect(
atom.config.get('foo.changes', { sources: [userConfigPath] })
).toBeUndefined()
}))
describe("when a 'scopeSelector' is given", () =>
it('sets the value and overrides the others', () => {
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee .string.quoted.double.coffee'
})
atom.config.set('foo.bar.baz', 22, {
scopeSelector: '.source .string.quoted.double'
})
atom.config.set('foo.bar.baz', 11, { scopeSelector: '.source' })
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string.quoted.double.coffee']
})
).toBe(42)
expect(
atom.config.set('foo.bar.baz', 100, {
scopeSelector: '.source.coffee .string.quoted.double.coffee'
})
).toBe(true)
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string.quoted.double.coffee']
})
).toBe(100)
}))
})
describe('.unset(keyPath, {source, scopeSelector})', () => {
beforeEach(() =>
atom.config.setSchema('foo', {
type: 'object',
properties: {
bar: {
type: 'object',
properties: {
baz: {
type: 'integer',
default: 0
},
ok: {
type: 'integer',
default: 0
}
}
},
quux: {
type: 'integer',
default: 0
}
}
})
)
it('sets the value of the key path to its default', () => {
atom.config.setDefaults('a', { b: 3 })
atom.config.set('a.b', 4)
expect(atom.config.get('a.b')).toBe(4)
atom.config.unset('a.b')
expect(atom.config.get('a.b')).toBe(3)
atom.config.set('a.c', 5)
expect(atom.config.get('a.c')).toBe(5)
atom.config.unset('a.c')
expect(atom.config.get('a.c')).toBeUndefined()
})
it('calls ::save()', () => {
atom.config.setDefaults('a', { b: 3 })
atom.config.set('a.b', 4)
savedSettings.length = 0
atom.config.unset('a.c')
advanceClock(500)
expect(savedSettings.length).toBe(1)
})
describe("when no 'scopeSelector' is given", () => {
describe("when a 'source' but no key-path is given", () =>
it('removes all scoped settings with the given source', () => {
atom.config.set('foo.bar.baz', 1, {
scopeSelector: '.a',
source: 'source-a'
})
atom.config.set('foo.bar.quux', 2, {
scopeSelector: '.b',
source: 'source-a'
})
expect(atom.config.get('foo.bar', { scope: ['.a.b'] })).toEqual({
baz: 1,
quux: 2
})
atom.config.unset(null, { source: 'source-a' })
expect(atom.config.get('foo.bar', { scope: ['.a'] })).toEqual({
baz: 0,
ok: 0
})
}))
describe("when a 'source' and a key-path is given", () =>
it('removes all scoped settings with the given source and key-path', () => {
atom.config.set('foo.bar.baz', 1)
atom.config.set('foo.bar.baz', 2, {
scopeSelector: '.a',
source: 'source-a'
})
atom.config.set('foo.bar.baz', 3, {
scopeSelector: '.a.b',
source: 'source-b'
})
expect(atom.config.get('foo.bar.baz', { scope: ['.a.b'] })).toEqual(3)
atom.config.unset('foo.bar.baz', { source: 'source-b' })
expect(atom.config.get('foo.bar.baz', { scope: ['.a.b'] })).toEqual(2)
expect(atom.config.get('foo.bar.baz')).toEqual(1)
}))
describe("when no 'source' is given", () =>
it('removes all scoped and unscoped properties for that key-path', () => {
atom.config.setDefaults('foo.bar', { baz: 100 })
atom.config.set('foo.bar', { baz: 1, ok: 2 }, { scopeSelector: '.a' })
atom.config.set(
'foo.bar',
{ baz: 11, ok: 12 },
{ scopeSelector: '.b' }
)
atom.config.set('foo.bar', { baz: 21, ok: 22 })
atom.config.unset('foo.bar.baz')
expect(atom.config.get('foo.bar.baz', { scope: ['.a'] })).toBe(100)
expect(atom.config.get('foo.bar.baz', { scope: ['.b'] })).toBe(100)
expect(atom.config.get('foo.bar.baz')).toBe(100)
expect(atom.config.get('foo.bar.ok', { scope: ['.a'] })).toBe(2)
expect(atom.config.get('foo.bar.ok', { scope: ['.b'] })).toBe(12)
expect(atom.config.get('foo.bar.ok')).toBe(22)
}))
})
describe("when a 'scopeSelector' is given", () => {
it('restores the global default when no scoped default set', () => {
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.set('foo.bar.baz', 55, { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(55)
atom.config.unset('foo.bar.baz', { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(10)
})
it('restores the scoped default when a scoped default is set', () => {
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee',
source: 'some-source'
})
atom.config.set('foo.bar.baz', 55, { scopeSelector: '.source.coffee' })
atom.config.set('foo.bar.ok', 100, { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(55)
atom.config.unset('foo.bar.baz', { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(42)
expect(
atom.config.get('foo.bar.ok', { scope: ['.source.coffee'] })
).toBe(100)
})
it('calls ::save()', () => {
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.set('foo.bar.baz', 55, { scopeSelector: '.source.coffee' })
savedSettings.length = 0
atom.config.unset('foo.bar.baz', { scopeSelector: '.source.coffee' })
advanceClock(150)
expect(savedSettings.length).toBe(1)
})
it('allows removing settings for a specific source and scope selector', () => {
atom.config.set('foo.bar.baz', 55, {
scopeSelector: '.source.coffee',
source: 'source-a'
})
atom.config.set('foo.bar.baz', 65, {
scopeSelector: '.source.coffee',
source: 'source-b'
})
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(65)
atom.config.unset('foo.bar.baz', {
source: 'source-b',
scopeSelector: '.source.coffee'
})
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string']
})
).toBe(55)
})
it('allows removing all settings for a specific source', () => {
atom.config.set('foo.bar.baz', 55, {
scopeSelector: '.source.coffee',
source: 'source-a'
})
atom.config.set('foo.bar.baz', 65, {
scopeSelector: '.source.coffee',
source: 'source-b'
})
atom.config.set('foo.bar.ok', 65, {
scopeSelector: '.source.coffee',
source: 'source-b'
})
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(65)
atom.config.unset(null, {
source: 'source-b',
scopeSelector: '.source.coffee'
})
expect(
atom.config.get('foo.bar.baz', {
scope: ['.source.coffee', '.string']
})
).toBe(55)
expect(
atom.config.get('foo.bar.ok', {
scope: ['.source.coffee', '.string']
})
).toBe(0)
})
it('does not call ::save or add a scoped property when no value has been set', () => {
// see https://github.com/atom/atom/issues/4175
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.unset('foo.bar.baz', { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(10)
expect(savedSettings.length).toBe(0)
const scopedProperties = atom.config.scopedSettingsStore.propertiesForSource(
'user-config'
)
expect(scopedProperties['.coffee.source']).toBeUndefined()
})
it('removes the scoped value when it was the only set value on the object', () => {
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.set('foo.bar.baz', 55, { scopeSelector: '.source.coffee' })
atom.config.set('foo.bar.ok', 20, { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(55)
advanceClock(150)
savedSettings.length = 0
atom.config.unset('foo.bar.baz', { scopeSelector: '.source.coffee' })
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(10)
expect(
atom.config.get('foo.bar.ok', { scope: ['.source.coffee'] })
).toBe(20)
advanceClock(150)
expect(savedSettings[0]['.coffee.source']).toEqual({
foo: {
bar: {
ok: 20
}
}
})
atom.config.unset('foo.bar.ok', { scopeSelector: '.source.coffee' })
advanceClock(150)
expect(savedSettings.length).toBe(2)
expect(savedSettings[1]['.coffee.source']).toBeUndefined()
})
it('does not call ::save when the value is already at the default', () => {
atom.config.setDefaults('foo', { bar: { baz: 10 } })
atom.config.set('foo.bar.baz', 55)
advanceClock(150)
savedSettings.length = 0
atom.config.unset('foo.bar.ok', { scopeSelector: '.source.coffee' })
advanceClock(150)
expect(savedSettings.length).toBe(0)
expect(
atom.config.get('foo.bar.baz', { scope: ['.source.coffee'] })
).toBe(55)
})
})
})
describe('.onDidChange(keyPath, {scope})', () => {
let observeHandler = []
describe('when a keyPath is specified', () => {
beforeEach(() => {
observeHandler = jasmine.createSpy('observeHandler')
atom.config.set('foo.bar.baz', 'value 1')
atom.config.onDidChange('foo.bar.baz', observeHandler)
})
it('does not fire the given callback with the current value at the keypath', () =>
expect(observeHandler).not.toHaveBeenCalled())
it('fires the callback every time the observed value changes', () => {
atom.config.set('foo.bar.baz', 'value 2')
expect(observeHandler).toHaveBeenCalledWith({
newValue: 'value 2',
oldValue: 'value 1'
})
observeHandler.reset()
observeHandler.andCallFake(() => {
throw new Error('oops')
})
expect(() => atom.config.set('foo.bar.baz', 'value 1')).toThrow('oops')
expect(observeHandler).toHaveBeenCalledWith({
newValue: 'value 1',
oldValue: 'value 2'
})
observeHandler.reset()
// Regression: exception in earlier handler shouldn't put observer
// into a bad state.
atom.config.set('something.else', 'new value')
expect(observeHandler).not.toHaveBeenCalled()
})
})
describe('when a keyPath is not specified', () => {
beforeEach(() => {
observeHandler = jasmine.createSpy('observeHandler')
atom.config.set('foo.bar.baz', 'value 1')
atom.config.onDidChange(observeHandler)
})
it('does not fire the given callback initially', () =>
expect(observeHandler).not.toHaveBeenCalled())
it('fires the callback every time any value changes', () => {
observeHandler.reset() // clear the initial call
atom.config.set('foo.bar.baz', 'value 2')
expect(observeHandler).toHaveBeenCalled()
expect(observeHandler.mostRecentCall.args[0].newValue.foo.bar.baz).toBe(
'value 2'
)
expect(observeHandler.mostRecentCall.args[0].oldValue.foo.bar.baz).toBe(
'value 1'
)
observeHandler.reset()
atom.config.set('foo.bar.baz', 'value 1')
expect(observeHandler).toHaveBeenCalled()
expect(observeHandler.mostRecentCall.args[0].newValue.foo.bar.baz).toBe(
'value 1'
)
expect(observeHandler.mostRecentCall.args[0].oldValue.foo.bar.baz).toBe(
'value 2'
)
observeHandler.reset()
atom.config.set('foo.bar.int', 1)
expect(observeHandler).toHaveBeenCalled()
expect(observeHandler.mostRecentCall.args[0].newValue.foo.bar.int).toBe(
1
)
expect(observeHandler.mostRecentCall.args[0].oldValue.foo.bar.int).toBe(
undefined
)
})
})
describe("when a 'scope' is given", () =>
it('calls the supplied callback when the value at the descriptor/keypath changes', () => {
const changeSpy = jasmine.createSpy('onDidChange callback')
atom.config.onDidChange(
'foo.bar.baz',
{ scope: ['.source.coffee', '.string.quoted.double.coffee'] },
changeSpy
)
atom.config.set('foo.bar.baz', 12)
expect(changeSpy).toHaveBeenCalledWith({
oldValue: undefined,
newValue: 12
})
changeSpy.reset()
atom.config.set('foo.bar.baz', 22, {
scopeSelector: '.source .string.quoted.double',
source: 'a'
})
expect(changeSpy).toHaveBeenCalledWith({ oldValue: 12, newValue: 22 })
changeSpy.reset()
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee .string.quoted.double.coffee',
source: 'b'
})
expect(changeSpy).toHaveBeenCalledWith({ oldValue: 22, newValue: 42 })
changeSpy.reset()
atom.config.unset(null, {
scopeSelector: '.source.coffee .string.quoted.double.coffee',
source: 'b'
})
expect(changeSpy).toHaveBeenCalledWith({ oldValue: 42, newValue: 22 })
changeSpy.reset()
atom.config.unset(null, {
scopeSelector: '.source .string.quoted.double',
source: 'a'
})
expect(changeSpy).toHaveBeenCalledWith({ oldValue: 22, newValue: 12 })
changeSpy.reset()
atom.config.set('foo.bar.baz', undefined)
expect(changeSpy).toHaveBeenCalledWith({
oldValue: 12,
newValue: undefined
})
changeSpy.reset()
}))
})
describe('.observe(keyPath, {scope})', () => {
let [observeHandler, observeSubscription] = []
beforeEach(() => {
observeHandler = jasmine.createSpy('observeHandler')
atom.config.set('foo.bar.baz', 'value 1')
observeSubscription = atom.config.observe('foo.bar.baz', observeHandler)
})
it('fires the given callback with the current value at the keypath', () =>
expect(observeHandler).toHaveBeenCalledWith('value 1'))
it('fires the callback every time the observed value changes', () => {
observeHandler.reset() // clear the initial call
atom.config.set('foo.bar.baz', 'value 2')
expect(observeHandler).toHaveBeenCalledWith('value 2')
observeHandler.reset()
atom.config.set('foo.bar.baz', 'value 1')
expect(observeHandler).toHaveBeenCalledWith('value 1')
advanceClock(100) // complete pending save that was requested in ::set
observeHandler.reset()
atom.config.resetUserSettings({ foo: {} })
expect(observeHandler).toHaveBeenCalledWith(undefined)
})
it('fires the callback when the observed value is deleted', () => {
observeHandler.reset() // clear the initial call
atom.config.set('foo.bar.baz', undefined)
expect(observeHandler).toHaveBeenCalledWith(undefined)
})
it('fires the callback when the full key path goes into and out of existence', () => {
observeHandler.reset() // clear the initial call
atom.config.set('foo.bar', undefined)
expect(observeHandler).toHaveBeenCalledWith(undefined)
observeHandler.reset()
atom.config.set('foo.bar.baz', "i'm back")
expect(observeHandler).toHaveBeenCalledWith("i'm back")
})
it('does not fire the callback once the subscription is disposed', () => {
observeHandler.reset() // clear the initial call
observeSubscription.dispose()
atom.config.set('foo.bar.baz', 'value 2')
expect(observeHandler).not.toHaveBeenCalled()
})
it('does not fire the callback for a similarly named keyPath', () => {
const bazCatHandler = jasmine.createSpy('bazCatHandler')
observeSubscription = atom.config.observe('foo.bar.bazCat', bazCatHandler)
bazCatHandler.reset()
atom.config.set('foo.bar.baz', 'value 10')
expect(bazCatHandler).not.toHaveBeenCalled()
})
describe("when a 'scope' is given", () => {
let otherHandler = null
beforeEach(() => {
observeSubscription.dispose()
otherHandler = jasmine.createSpy('otherHandler')
})
it('allows settings to be observed in a specific scope', () => {
atom.config.observe(
'foo.bar.baz',
{ scope: ['.some.scope'] },
observeHandler
)
atom.config.observe(
'foo.bar.baz',
{ scope: ['.another.scope'] },
otherHandler
)
atom.config.set('foo.bar.baz', 'value 2', { scopeSelector: '.some' })
expect(observeHandler).toHaveBeenCalledWith('value 2')
expect(otherHandler).not.toHaveBeenCalledWith('value 2')
})
it('calls the callback when properties with more specific selectors are removed', () => {
const changeSpy = jasmine.createSpy()
atom.config.observe(
'foo.bar.baz',
{ scope: ['.source.coffee', '.string.quoted.double.coffee'] },
changeSpy
)
expect(changeSpy).toHaveBeenCalledWith('value 1')
changeSpy.reset()
atom.config.set('foo.bar.baz', 12)
expect(changeSpy).toHaveBeenCalledWith(12)
changeSpy.reset()
atom.config.set('foo.bar.baz', 22, {
scopeSelector: '.source .string.quoted.double',
source: 'a'
})
expect(changeSpy).toHaveBeenCalledWith(22)
changeSpy.reset()
atom.config.set('foo.bar.baz', 42, {
scopeSelector: '.source.coffee .string.quoted.double.coffee',
source: 'b'
})
expect(changeSpy).toHaveBeenCalledWith(42)
changeSpy.reset()
atom.config.unset(null, {
scopeSelector: '.source.coffee .string.quoted.double.coffee',
source: 'b'
})
expect(changeSpy).toHaveBeenCalledWith(22)
changeSpy.reset()
atom.config.unset(null, {
scopeSelector: '.source .string.quoted.double',
source: 'a'
})
expect(changeSpy).toHaveBeenCalledWith(12)
changeSpy.reset()
atom.config.set('foo.bar.baz', undefined)
expect(changeSpy).toHaveBeenCalledWith(undefined)
changeSpy.reset()
})
})
})
describe('.transact(callback)', () => {
let changeSpy = null
beforeEach(() => {
changeSpy = jasmine.createSpy('onDidChange callback')
atom.config.onDidChange('foo.bar.baz', changeSpy)
})
it('allows only one change event for the duration of the given callback', () => {
atom.config.transact(() => {
atom.config.set('foo.bar.baz', 1)
atom.config.set('foo.bar.baz', 2)
atom.config.set('foo.bar.baz', 3)
})
expect(changeSpy.callCount).toBe(1)
expect(changeSpy.argsForCall[0][0]).toEqual({
newValue: 3,
oldValue: undefined
})
})
it('does not emit an event if no changes occur while paused', () => {
atom.config.transact(() => {})
expect(changeSpy).not.toHaveBeenCalled()
})
})
describe('.transactAsync(callback)', () => {
let changeSpy = null
beforeEach(() => {
changeSpy = jasmine.createSpy('onDidChange callback')
atom.config.onDidChange('foo.bar.baz', changeSpy)
})
it('allows only one change event for the duration of the given promise if it gets resolved', () => {
let promiseResult = null
const transactionPromise = atom.config.transactAsync(() => {
atom.config.set('foo.bar.baz', 1)
atom.config.set('foo.bar.baz', 2)
atom.config.set('foo.bar.baz', 3)
return Promise.resolve('a result')
})
waitsForPromise(() =>
transactionPromise.then(result => {
promiseResult = result
})
)
runs(() => {
expect(promiseResult).toBe('a result')
expect(changeSpy.callCount).toBe(1)
expect(changeSpy.argsForCall[0][0]).toEqual({
newValue: 3,
oldValue: undefined
})
})
})
it('allows only one change event for the duration of the given promise if it gets rejected', () => {
let promiseError = null
const transactionPromise = atom.config.transactAsync(() => {
atom.config.set('foo.bar.baz', 1)
atom.config.set('foo.bar.baz', 2)
atom.config.set('foo.bar.baz', 3)
return Promise.reject(new Error('an error'))
})
waitsForPromise(() =>
transactionPromise.catch(error => {
promiseError = error
})
)
runs(() => {
expect(promiseError.message).toBe('an error')
expect(changeSpy.callCount).toBe(1)
expect(changeSpy.argsForCall[0][0]).toEqual({
newValue: 3,
oldValue: undefined
})
})
})
it('allows only one change event even when the given callback throws', () => {
const error = new Error('Oops!')
let promiseError = null
const transactionPromise = atom.config.transactAsync(() => {
atom.config.set('foo.bar.baz', 1)
atom.config.set('foo.bar.baz', 2)
atom.config.set('foo.bar.baz', 3)
throw error
})
waitsForPromise(() =>
transactionPromise.catch(e => {
promiseError = e
})
)
runs(() => {
expect(promiseError).toBe(error)
expect(changeSpy.callCount).toBe(1)
expect(changeSpy.argsForCall[0][0]).toEqual({
newValue: 3,
oldValue: undefined
})
})
})
})
describe('.getSources()', () => {
it("returns an array of all of the config's source names", () => {
expect(atom.config.getSources()).toEqual([])
atom.config.set('a.b', 1, { scopeSelector: '.x1', source: 'source-1' })
atom.config.set('a.c', 1, { scopeSelector: '.x1', source: 'source-1' })
atom.config.set('a.b', 2, { scopeSelector: '.x2', source: 'source-2' })
atom.config.set('a.b', 1, { scopeSelector: '.x3', source: 'source-3' })
expect(atom.config.getSources()).toEqual([
'source-1',
'source-2',
'source-3'
])
})
})
describe('.save()', () => {
it('calls the save callback with any non-default properties', () => {
atom.config.set('a.b.c', 1)
atom.config.set('a.b.d', 2)
atom.config.set('x.y.z', 3)
atom.config.setDefaults('a.b', { e: 4, f: 5 })
atom.config.save()
expect(savedSettings).toEqual([{ '*': atom.config.settings }])
})
it('serializes properties in alphabetical order', () => {
atom.config.set('foo', 1)
atom.config.set('bar', 2)
atom.config.set('baz.foo', 3)
atom.config.set('baz.bar', 4)
savedSettings.length = 0
atom.config.save()
const writtenConfig = savedSettings[0]
expect(writtenConfig).toEqual({ '*': atom.config.settings })
let expectedKeys = ['bar', 'baz', 'foo']
let foundKeys = []
for (const key in writtenConfig['*']) {
if (expectedKeys.includes(key)) {
foundKeys.push(key)
}
}
expect(foundKeys).toEqual(expectedKeys)
expectedKeys = ['bar', 'foo']
foundKeys = []
for (const key in writtenConfig['*']['baz']) {
if (expectedKeys.includes(key)) {
foundKeys.push(key)
}
}
expect(foundKeys).toEqual(expectedKeys)
})
describe('when scoped settings are defined', () => {
it('serializes any explicitly set config settings', () => {
atom.config.set('foo.bar', 'ruby', { scopeSelector: '.source.ruby' })
atom.config.set('foo.omg', 'wow', { scopeSelector: '.source.ruby' })
atom.config.set('foo.bar', 'coffee', {
scopeSelector: '.source.coffee'
})
savedSettings.length = 0
atom.config.save()
const writtenConfig = savedSettings[0]
expect(writtenConfig).toEqualJson({
'*': atom.config.settings,
'.ruby.source': {
foo: {
bar: 'ruby',
omg: 'wow'
}
},
'.coffee.source': {
foo: {
bar: 'coffee'
}
}
})
})
})
})
describe('.resetUserSettings()', () => {
beforeEach(() => {
atom.config.setSchema('foo', {
type: 'object',
properties: {
bar: {
type: 'string',
default: 'def'
},
int: {
type: 'integer',
default: 12
}
}
})
})
describe('when the config file contains scoped settings', () => {
it('updates the config data based on the file contents', () => {
atom.config.resetUserSettings({
'*': {
foo: {
bar: 'baz'
}
},
'.source.ruby': {
foo: {
bar: 'more-specific'
}
}
})
expect(atom.config.get('foo.bar')).toBe('baz')
expect(atom.config.get('foo.bar', { scope: ['.source.ruby'] })).toBe(
'more-specific'
)
})
})
describe('when the config file does not conform to the schema', () => {
it('validates and does not load the incorrect values', () => {
atom.config.resetUserSettings({
'*': {
foo: {
bar: 'omg',
int: 'baz'
}
},
'.source.ruby': {
foo: {
bar: 'scoped',
int: 'nope'
}
}
})
expect(atom.config.get('foo.int')).toBe(12)
expect(atom.config.get('foo.bar')).toBe('omg')
expect(atom.config.get('foo.int', { scope: ['.source.ruby'] })).toBe(12)
expect(atom.config.get('foo.bar', { scope: ['.source.ruby'] })).toBe(
'scoped'
)
})
})
it('updates the config data based on the file contents', () => {
atom.config.resetUserSettings({ foo: { bar: 'baz' } })
expect(atom.config.get('foo.bar')).toBe('baz')
})
it('notifies observers for updated keypaths on load', () => {
const observeHandler = jasmine.createSpy('observeHandler')
atom.config.observe('foo.bar', observeHandler)
atom.config.resetUserSettings({ foo: { bar: 'baz' } })
expect(observeHandler).toHaveBeenCalledWith('baz')
})
describe('when the config file contains values that do not adhere to the schema', () => {
it('updates the only the settings that have values matching the schema', () => {
atom.config.resetUserSettings({
foo: {
bar: 'baz',
int: 'bad value'
}
})
expect(atom.config.get('foo.bar')).toBe('baz')
expect(atom.config.get('foo.int')).toBe(12)
expect(console.warn).toHaveBeenCalled()
expect(console.warn.mostRecentCall.args[0]).toContain('foo.int')
})
})
it('does not fire a change event for paths that did not change', () => {
atom.config.resetUserSettings({
foo: { bar: 'baz', int: 3 }
})
const noChangeSpy = jasmine.createSpy('unchanged')
atom.config.onDidChange('foo.bar', noChangeSpy)
atom.config.resetUserSettings({
foo: { bar: 'baz', int: 4 }
})
expect(noChangeSpy).not.toHaveBeenCalled()
expect(atom.config.get('foo.bar')).toBe('baz')
expect(atom.config.get('foo.int')).toBe(4)
})
it('does not fire a change event for paths whose non-primitive values did not change', () => {
atom.config.setSchema('foo.bar', {
type: 'array',
items: {
type: 'string'
}
})
atom.config.resetUserSettings({
foo: { bar: ['baz', 'quux'], int: 2 }
})
const noChangeSpy = jasmine.createSpy('unchanged')
atom.config.onDidChange('foo.bar', noChangeSpy)
atom.config.resetUserSettings({
foo: { bar: ['baz', 'quux'], int: 2 }
})
expect(noChangeSpy).not.toHaveBeenCalled()
expect(atom.config.get('foo.bar')).toEqual(['baz', 'quux'])
})
describe('when a setting with a default is removed', () => {
it('resets the setting back to the default', () => {
atom.config.resetUserSettings({
foo: { bar: ['baz', 'quux'], int: 2 }
})
const events = []
atom.config.onDidChange('foo.int', event => events.push(event))
atom.config.resetUserSettings({
foo: { bar: ['baz', 'quux'] }
})
expect(events.length).toBe(1)
expect(events[0]).toEqual({ oldValue: 2, newValue: 12 })
})
})
it('keeps all the global scope settings after overriding one', () => {
atom.config.resetUserSettings({
'*': {
foo: {
bar: 'baz',
int: 99
}
}
})
atom.config.set('foo.int', 50, { scopeSelector: '*' })
advanceClock(100)
expect(savedSettings[0]['*'].foo).toEqual({
bar: 'baz',
int: 50
})
expect(atom.config.get('foo.int', { scope: ['*'] })).toEqual(50)
expect(atom.config.get('foo.bar', { scope: ['*'] })).toEqual('baz')
expect(atom.config.get('foo.int')).toEqual(50)
})
})
describe('.pushAtKeyPath(keyPath, value)', () => {
it('pushes the given value to the array at the key path and updates observers', () => {
atom.config.set('foo.bar.baz', ['a'])
const observeHandler = jasmine.createSpy('observeHandler')
atom.config.observe('foo.bar.baz', observeHandler)
observeHandler.reset()
expect(atom.config.pushAtKeyPath('foo.bar.baz', 'b')).toBe(2)
expect(atom.config.get('foo.bar.baz')).toEqual(['a', 'b'])
expect(observeHandler).toHaveBeenCalledWith(
atom.config.get('foo.bar.baz')
)
})
})
describe('.unshiftAtKeyPath(keyPath, value)', () => {
it('unshifts the given value to the array at the key path and updates observers', () => {
atom.config.set('foo.bar.baz', ['b'])
const observeHandler = jasmine.createSpy('observeHandler')
atom.config.observe('foo.bar.baz', observeHandler)
observeHandler.reset()
expect(atom.config.unshiftAtKeyPath('foo.bar.baz', 'a')).toBe(2)
expect(atom.config.get('foo.bar.baz')).toEqual(['a', 'b'])
expect(observeHandler).toHaveBeenCalledWith(
atom.config.get('foo.bar.baz')
)
})
})
describe('.removeAtKeyPath(keyPath, value)', () => {
it('removes the given value from the array at the key path and updates observers', () => {
atom.config.set('foo.bar.baz', ['a', 'b', 'c'])
const observeHandler = jasmine.createSpy('observeHandler')
atom.config.observe('foo.bar.baz', observeHandler)
observeHandler.reset()
expect(atom.config.removeAtKeyPath('foo.bar.baz', 'b')).toEqual([
'a',
'c'
])
expect(atom.config.get('foo.bar.baz')).toEqual(['a', 'c'])
expect(observeHandler).toHaveBeenCalledWith(
atom.config.get('foo.bar.baz')
)
})
})
describe('.setDefaults(keyPath, defaults)', () => {
it('assigns any previously-unassigned keys to the object at the key path', () => {
atom.config.set('foo.bar.baz', { a: 1 })
atom.config.setDefaults('foo.bar.baz', { a: 2, b: 3, c: 4 })
expect(atom.config.get('foo.bar.baz.a')).toBe(1)
expect(atom.config.get('foo.bar.baz.b')).toBe(3)
expect(atom.config.get('foo.bar.baz.c')).toBe(4)
atom.config.setDefaults('foo.quux', { x: 0, y: 1 })
expect(atom.config.get('foo.quux.x')).toBe(0)
expect(atom.config.get('foo.quux.y')).toBe(1)
})
it('emits an updated event', () => {
const updatedCallback = jasmine.createSpy('updated')
atom.config.onDidChange('foo.bar.baz.a', updatedCallback)
expect(updatedCallback.callCount).toBe(0)
atom.config.setDefaults('foo.bar.baz', { a: 2 })
expect(updatedCallback.callCount).toBe(1)
})
})
describe('.setSchema(keyPath, schema)', () => {
it('creates a properly nested schema', () => {
const schema = {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
}
}
atom.config.setSchema('foo.bar', schema)
expect(atom.config.getSchema('foo')).toEqual({
type: 'object',
properties: {
bar: {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
}
}
}
})
})
it('sets defaults specified by the schema', () => {
const schema = {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
},
anObject: {
type: 'object',
properties: {
nestedInt: {
type: 'integer',
default: 24
},
nestedObject: {
type: 'object',
properties: {
superNestedInt: {
type: 'integer',
default: 36
}
}
}
}
}
}
}
atom.config.setSchema('foo.bar', schema)
expect(atom.config.get('foo.bar.anInt')).toBe(12)
expect(atom.config.get('foo.bar.anObject')).toEqual({
nestedInt: 24,
nestedObject: {
superNestedInt: 36
}
})
expect(atom.config.get('foo')).toEqual({
bar: {
anInt: 12,
anObject: {
nestedInt: 24,
nestedObject: {
superNestedInt: 36
}
}
}
})
atom.config.set('foo.bar.anObject.nestedObject.superNestedInt', 37)
expect(atom.config.get('foo')).toEqual({
bar: {
anInt: 12,
anObject: {
nestedInt: 24,
nestedObject: {
superNestedInt: 37
}
}
}
})
})
it('can set a non-object schema', () => {
const schema = {
type: 'integer',
default: 12
}
atom.config.setSchema('foo.bar.anInt', schema)
expect(atom.config.get('foo.bar.anInt')).toBe(12)
expect(atom.config.getSchema('foo.bar.anInt')).toEqual({
type: 'integer',
default: 12
})
})
it('allows the schema to be retrieved via ::getSchema', () => {
const schema = {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
}
}
atom.config.setSchema('foo.bar', schema)
expect(atom.config.getSchema('foo.bar')).toEqual({
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
}
})
expect(atom.config.getSchema('foo.bar.anInt')).toEqual({
type: 'integer',
default: 12
})
expect(atom.config.getSchema('foo.baz')).toEqual({ type: 'any' })
expect(atom.config.getSchema('foo.bar.anInt.baz')).toBe(null)
})
it('respects the schema for scoped settings', () => {
const schema = {
type: 'string',
default: 'ok',
scopes: {
'.source.js': {
default: 'omg'
}
}
}
atom.config.setSchema('foo.bar.str', schema)
expect(atom.config.get('foo.bar.str')).toBe('ok')
expect(atom.config.get('foo.bar.str', { scope: ['.source.js'] })).toBe(
'omg'
)
expect(
atom.config.get('foo.bar.str', { scope: ['.source.coffee'] })
).toBe('ok')
})
describe('when a schema is added after config values have been set', () => {
let schema = null
beforeEach(() => {
schema = {
type: 'object',
properties: {
int: {
type: 'integer',
default: 2
},
str: {
type: 'string',
default: 'def'
}
}
}
})
it('respects the new schema when values are set', () => {
expect(atom.config.set('foo.bar.str', 'global')).toBe(true)
expect(
atom.config.set('foo.bar.str', 'scoped', {
scopeSelector: '.source.js'
})
).toBe(true)
expect(atom.config.get('foo.bar.str')).toBe('global')
expect(atom.config.get('foo.bar.str', { scope: ['.source.js'] })).toBe(
'scoped'
)
expect(atom.config.set('foo.bar.noschema', 'nsGlobal')).toBe(true)
expect(
atom.config.set('foo.bar.noschema', 'nsScoped', {
scopeSelector: '.source.js'
})
).toBe(true)
expect(atom.config.get('foo.bar.noschema')).toBe('nsGlobal')
expect(
atom.config.get('foo.bar.noschema', { scope: ['.source.js'] })
).toBe('nsScoped')
expect(atom.config.set('foo.bar.int', 'nope')).toBe(true)
expect(
atom.config.set('foo.bar.int', 'notanint', {
scopeSelector: '.source.js'
})
).toBe(true)
expect(
atom.config.set('foo.bar.int', 23, {
scopeSelector: '.source.coffee'
})
).toBe(true)
expect(atom.config.get('foo.bar.int')).toBe('nope')
expect(atom.config.get('foo.bar.int', { scope: ['.source.js'] })).toBe(
'notanint'
)
expect(
atom.config.get('foo.bar.int', { scope: ['.source.coffee'] })
).toBe(23)
atom.config.setSchema('foo.bar', schema)
expect(atom.config.get('foo.bar.str')).toBe('global')
expect(atom.config.get('foo.bar.str', { scope: ['.source.js'] })).toBe(
'scoped'
)
expect(atom.config.get('foo.bar.noschema')).toBe('nsGlobal')
expect(
atom.config.get('foo.bar.noschema', { scope: ['.source.js'] })
).toBe('nsScoped')
expect(atom.config.get('foo.bar.int')).toBe(2)
expect(atom.config.get('foo.bar.int', { scope: ['.source.js'] })).toBe(
2
)
expect(
atom.config.get('foo.bar.int', { scope: ['.source.coffee'] })
).toBe(23)
})
it('sets all values that adhere to the schema', () => {
expect(atom.config.set('foo.bar.int', 10)).toBe(true)
expect(
atom.config.set('foo.bar.int', 15, { scopeSelector: '.source.js' })
).toBe(true)
expect(
atom.config.set('foo.bar.int', 23, {
scopeSelector: '.source.coffee'
})
).toBe(true)
expect(atom.config.get('foo.bar.int')).toBe(10)
expect(atom.config.get('foo.bar.int', { scope: ['.source.js'] })).toBe(
15
)
expect(
atom.config.get('foo.bar.int', { scope: ['.source.coffee'] })
).toBe(23)
atom.config.setSchema('foo.bar', schema)
expect(atom.config.get('foo.bar.int')).toBe(10)
expect(atom.config.get('foo.bar.int', { scope: ['.source.js'] })).toBe(
15
)
expect(
atom.config.get('foo.bar.int', { scope: ['.source.coffee'] })
).toBe(23)
})
})
describe('when the value has an "integer" type', () => {
beforeEach(() => {
const schema = {
type: 'integer',
default: 12
}
atom.config.setSchema('foo.bar.anInt', schema)
})
it('coerces a string to an int', () => {
atom.config.set('foo.bar.anInt', '123')
expect(atom.config.get('foo.bar.anInt')).toBe(123)
})
it('does not allow infinity', () => {
atom.config.set('foo.bar.anInt', Infinity)
expect(atom.config.get('foo.bar.anInt')).toBe(12)
})
it('coerces a float to an int', () => {
atom.config.set('foo.bar.anInt', 12.3)
expect(atom.config.get('foo.bar.anInt')).toBe(12)
})
it('will not set non-integers', () => {
atom.config.set('foo.bar.anInt', null)
expect(atom.config.get('foo.bar.anInt')).toBe(12)
atom.config.set('foo.bar.anInt', 'nope')
expect(atom.config.get('foo.bar.anInt')).toBe(12)
})
describe('when the minimum and maximum keys are used', () => {
beforeEach(() => {
const schema = {
type: 'integer',
minimum: 10,
maximum: 20,
default: 12
}
atom.config.setSchema('foo.bar.anInt', schema)
})
it('keeps the specified value within the specified range', () => {
atom.config.set('foo.bar.anInt', '123')
expect(atom.config.get('foo.bar.anInt')).toBe(20)
atom.config.set('foo.bar.anInt', '1')
expect(atom.config.get('foo.bar.anInt')).toBe(10)
})
})
})
describe('when the value has an "integer" and "string" type', () => {
beforeEach(() => {
const schema = {
type: ['integer', 'string'],
default: 12
}
atom.config.setSchema('foo.bar.anInt', schema)
})
it('can coerce an int, and fallback to a string', () => {
atom.config.set('foo.bar.anInt', '123')
expect(atom.config.get('foo.bar.anInt')).toBe(123)
atom.config.set('foo.bar.anInt', 'cats')
expect(atom.config.get('foo.bar.anInt')).toBe('cats')
})
})
describe('when the value has an "string" and "boolean" type', () => {
beforeEach(() => {
const schema = {
type: ['string', 'boolean'],
default: 'def'
}
atom.config.setSchema('foo.bar', schema)
})
it('can set a string, a boolean, and revert back to the default', () => {
atom.config.set('foo.bar', 'ok')
expect(atom.config.get('foo.bar')).toBe('ok')
atom.config.set('foo.bar', false)
expect(atom.config.get('foo.bar')).toBe(false)
atom.config.set('foo.bar', undefined)
expect(atom.config.get('foo.bar')).toBe('def')
})
})
describe('when the value has a "number" type', () => {
beforeEach(() => {
const schema = {
type: 'number',
default: 12.1
}
atom.config.setSchema('foo.bar.aFloat', schema)
})
it('coerces a string to a float', () => {
atom.config.set('foo.bar.aFloat', '12.23')
expect(atom.config.get('foo.bar.aFloat')).toBe(12.23)
})
it('will not set non-numbers', () => {
atom.config.set('foo.bar.aFloat', null)
expect(atom.config.get('foo.bar.aFloat')).toBe(12.1)
atom.config.set('foo.bar.aFloat', 'nope')
expect(atom.config.get('foo.bar.aFloat')).toBe(12.1)
})
describe('when the minimum and maximum keys are used', () => {
beforeEach(() => {
const schema = {
type: 'number',
minimum: 11.2,
maximum: 25.4,
default: 12.1
}
atom.config.setSchema('foo.bar.aFloat', schema)
})
it('keeps the specified value within the specified range', () => {
atom.config.set('foo.bar.aFloat', '123.2')
expect(atom.config.get('foo.bar.aFloat')).toBe(25.4)
atom.config.set('foo.bar.aFloat', '1.0')
expect(atom.config.get('foo.bar.aFloat')).toBe(11.2)
})
})
})
describe('when the value has a "boolean" type', () => {
beforeEach(() => {
const schema = {
type: 'boolean',
default: true
}
atom.config.setSchema('foo.bar.aBool', schema)
})
it('coerces various types to a boolean', () => {
atom.config.set('foo.bar.aBool', 'true')
expect(atom.config.get('foo.bar.aBool')).toBe(true)
atom.config.set('foo.bar.aBool', 'false')
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', 'TRUE')
expect(atom.config.get('foo.bar.aBool')).toBe(true)
atom.config.set('foo.bar.aBool', 'FALSE')
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', 1)
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', 0)
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', {})
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', null)
expect(atom.config.get('foo.bar.aBool')).toBe(false)
})
it('reverts back to the default value when undefined is passed to set', () => {
atom.config.set('foo.bar.aBool', 'false')
expect(atom.config.get('foo.bar.aBool')).toBe(false)
atom.config.set('foo.bar.aBool', undefined)
expect(atom.config.get('foo.bar.aBool')).toBe(true)
})
})
describe('when the value has an "string" type', () => {
beforeEach(() => {
const schema = {
type: 'string',
default: 'ok'
}
atom.config.setSchema('foo.bar.aString', schema)
})
it('allows strings', () => {
atom.config.set('foo.bar.aString', 'yep')
expect(atom.config.get('foo.bar.aString')).toBe('yep')
})
it('will only set strings', () => {
expect(atom.config.set('foo.bar.aString', 123)).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
expect(atom.config.set('foo.bar.aString', true)).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
expect(atom.config.set('foo.bar.aString', null)).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
expect(atom.config.set('foo.bar.aString', [])).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
expect(atom.config.set('foo.bar.aString', { nope: 'nope' })).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
})
it('does not allow setting children of that key-path', () => {
expect(atom.config.set('foo.bar.aString.something', 123)).toBe(false)
expect(atom.config.get('foo.bar.aString')).toBe('ok')
})
describe('when the schema has a "maximumLength" key', () =>
it('trims the string to be no longer than the specified maximum', () => {
const schema = {
type: 'string',
default: 'ok',
maximumLength: 3
}
atom.config.setSchema('foo.bar.aString', schema)
atom.config.set('foo.bar.aString', 'abcdefg')
expect(atom.config.get('foo.bar.aString')).toBe('abc')
}))
})
describe('when the value has an "object" type', () => {
beforeEach(() => {
const schema = {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
},
nestedObject: {
type: 'object',
properties: {
nestedBool: {
type: 'boolean',
default: false
}
}
}
}
}
atom.config.setSchema('foo.bar', schema)
})
it('converts and validates all the children', () => {
atom.config.set('foo.bar', {
anInt: '23',
nestedObject: {
nestedBool: 'true'
}
})
expect(atom.config.get('foo.bar')).toEqual({
anInt: 23,
nestedObject: {
nestedBool: true
}
})
})
it('will set only the values that adhere to the schema', () => {
expect(
atom.config.set('foo.bar', {
anInt: 'nope',
nestedObject: {
nestedBool: true
}
})
).toBe(true)
expect(atom.config.get('foo.bar.anInt')).toEqual(12)
expect(atom.config.get('foo.bar.nestedObject.nestedBool')).toEqual(true)
})
describe('when the value has additionalProperties set to false', () =>
it('does not allow other properties to be set on the object', () => {
atom.config.setSchema('foo.bar', {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
},
additionalProperties: false
})
expect(
atom.config.set('foo.bar', { anInt: 5, somethingElse: 'ok' })
).toBe(true)
expect(atom.config.get('foo.bar.anInt')).toBe(5)
expect(atom.config.get('foo.bar.somethingElse')).toBeUndefined()
expect(atom.config.set('foo.bar.somethingElse', { anInt: 5 })).toBe(
false
)
expect(atom.config.get('foo.bar.somethingElse')).toBeUndefined()
}))
describe('when the value has an additionalProperties schema', () =>
it('validates properties of the object against that schema', () => {
atom.config.setSchema('foo.bar', {
type: 'object',
properties: {
anInt: {
type: 'integer',
default: 12
}
},
additionalProperties: {
type: 'string'
}
})
expect(
atom.config.set('foo.bar', { anInt: 5, somethingElse: 'ok' })
).toBe(true)
expect(atom.config.get('foo.bar.anInt')).toBe(5)
expect(atom.config.get('foo.bar.somethingElse')).toBe('ok')
expect(atom.config.set('foo.bar.somethingElse', 7)).toBe(false)
expect(atom.config.get('foo.bar.somethingElse')).toBe('ok')
expect(
atom.config.set('foo.bar', { anInt: 6, somethingElse: 7 })
).toBe(true)
expect(atom.config.get('foo.bar.anInt')).toBe(6)
expect(atom.config.get('foo.bar.somethingElse')).toBe(undefined)
}))
})
describe('when the value has an "array" type', () => {
beforeEach(() => {
const schema = {
type: 'array',
default: [1, 2, 3],
items: {
type: 'integer'
}
}
atom.config.setSchema('foo.bar', schema)
})
it('converts an array of strings to an array of ints', () => {
atom.config.set('foo.bar', ['2', '3', '4'])
expect(atom.config.get('foo.bar')).toEqual([2, 3, 4])
})
it('does not allow setting children of that key-path', () => {
expect(atom.config.set('foo.bar.child', 123)).toBe(false)
expect(atom.config.set('foo.bar.child.grandchild', 123)).toBe(false)
expect(atom.config.get('foo.bar')).toEqual([1, 2, 3])
})
})
describe('when the value has a "color" type', () => {
beforeEach(() => {
const schema = {
type: 'color',
default: 'white'
}
atom.config.setSchema('foo.bar.aColor', schema)
})
it('returns a Color object', () => {
let color = atom.config.get('foo.bar.aColor')
expect(color.toHexString()).toBe('#ffffff')
expect(color.toRGBAString()).toBe('rgba(255, 255, 255, 1)')
color.red = 0
color.green = 0
color.blue = 0
color.alpha = 0
atom.config.set('foo.bar.aColor', color)
color = atom.config.get('foo.bar.aColor')
expect(color.toHexString()).toBe('#000000')
expect(color.toRGBAString()).toBe('rgba(0, 0, 0, 0)')
color.red = 300
color.green = -200
color.blue = -1
color.alpha = 'not see through'
atom.config.set('foo.bar.aColor', color)
color = atom.config.get('foo.bar.aColor')
expect(color.toHexString()).toBe('#ff0000')
expect(color.toRGBAString()).toBe('rgba(255, 0, 0, 1)')
color.red = 11
color.green = 11
color.blue = 124
color.alpha = 1
atom.config.set('foo.bar.aColor', color)
color = atom.config.get('foo.bar.aColor')
expect(color.toHexString()).toBe('#0b0b7c')
expect(color.toRGBAString()).toBe('rgba(11, 11, 124, 1)')
})
it('coerces various types to a color object', () => {
atom.config.set('foo.bar.aColor', 'red')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 0,
blue: 0,
alpha: 1
})
atom.config.set('foo.bar.aColor', '#020')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 0,
green: 34,
blue: 0,
alpha: 1
})
atom.config.set('foo.bar.aColor', '#abcdef')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 171,
green: 205,
blue: 239,
alpha: 1
})
atom.config.set('foo.bar.aColor', 'rgb(1,2,3)')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 1,
green: 2,
blue: 3,
alpha: 1
})
atom.config.set('foo.bar.aColor', 'rgba(4,5,6,.7)')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 4,
green: 5,
blue: 6,
alpha: 0.7
})
atom.config.set('foo.bar.aColor', 'hsl(120,100%,50%)')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 0,
green: 255,
blue: 0,
alpha: 1
})
atom.config.set('foo.bar.aColor', 'hsla(120,100%,50%,0.3)')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 0,
green: 255,
blue: 0,
alpha: 0.3
})
atom.config.set('foo.bar.aColor', {
red: 100,
green: 255,
blue: 2,
alpha: 0.5
})
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 100,
green: 255,
blue: 2,
alpha: 0.5
})
atom.config.set('foo.bar.aColor', { red: 255 })
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 0,
blue: 0,
alpha: 1
})
atom.config.set('foo.bar.aColor', { red: 1000 })
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 0,
blue: 0,
alpha: 1
})
atom.config.set('foo.bar.aColor', { red: 'dark' })
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 0,
green: 0,
blue: 0,
alpha: 1
})
})
it('reverts back to the default value when undefined is passed to set', () => {
atom.config.set('foo.bar.aColor', undefined)
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 255,
blue: 255,
alpha: 1
})
})
it('will not set non-colors', () => {
atom.config.set('foo.bar.aColor', null)
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 255,
blue: 255,
alpha: 1
})
atom.config.set('foo.bar.aColor', 'nope')
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 255,
blue: 255,
alpha: 1
})
atom.config.set('foo.bar.aColor', 30)
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 255,
blue: 255,
alpha: 1
})
atom.config.set('foo.bar.aColor', false)
expect(atom.config.get('foo.bar.aColor')).toEqual({
red: 255,
green: 255,
blue: 255,
alpha: 1
})
})
it('returns a clone of the Color when returned in a parent object', () => {
const color1 = atom.config.get('foo.bar').aColor
const color2 = atom.config.get('foo.bar').aColor
expect(color1.toRGBAString()).toBe('rgba(255, 255, 255, 1)')
expect(color2.toRGBAString()).toBe('rgba(255, 255, 255, 1)')
expect(color1).not.toBe(color2)
expect(color1).toEqual(color2)
})
})
describe('when the `enum` key is used', () => {
beforeEach(() => {
const schema = {
type: 'object',
properties: {
str: {
type: 'string',
default: 'ok',
enum: ['ok', 'one', 'two']
},
int: {
type: 'integer',
default: 2,
enum: [2, 3, 5]
},
arr: {
type: 'array',
default: ['one', 'two'],
items: {
type: 'string',
enum: ['one', 'two', 'three']
}
},
str_options: {
type: 'string',
default: 'one',
enum: [
{ value: 'one', description: 'One' },
'two',
{ value: 'three', description: 'Three' }
]
}
}
}
atom.config.setSchema('foo.bar', schema)
})
it('will only set a string when the string is in the enum values', () => {
expect(atom.config.set('foo.bar.str', 'nope')).toBe(false)
expect(atom.config.get('foo.bar.str')).toBe('ok')
expect(atom.config.set('foo.bar.str', 'one')).toBe(true)
expect(atom.config.get('foo.bar.str')).toBe('one')
})
it('will only set an integer when the integer is in the enum values', () => {
expect(atom.config.set('foo.bar.int', '400')).toBe(false)
expect(atom.config.get('foo.bar.int')).toBe(2)
expect(atom.config.set('foo.bar.int', '3')).toBe(true)
expect(atom.config.get('foo.bar.int')).toBe(3)
})
it('will only set an array when the array values are in the enum values', () => {
expect(atom.config.set('foo.bar.arr', ['one', 'five'])).toBe(true)
expect(atom.config.get('foo.bar.arr')).toEqual(['one'])
expect(atom.config.set('foo.bar.arr', ['two', 'three'])).toBe(true)
expect(atom.config.get('foo.bar.arr')).toEqual(['two', 'three'])
})
it('will honor the enum when specified as an array', () => {
expect(atom.config.set('foo.bar.str_options', 'one')).toBe(true)
expect(atom.config.get('foo.bar.str_options')).toEqual('one')
expect(atom.config.set('foo.bar.str_options', 'two')).toBe(true)
expect(atom.config.get('foo.bar.str_options')).toEqual('two')
expect(atom.config.set('foo.bar.str_options', 'One')).toBe(false)
expect(atom.config.get('foo.bar.str_options')).toEqual('two')
})
})
})
describe('when .set/.unset is called prior to .resetUserSettings', () => {
beforeEach(() => {
atom.config.settingsLoaded = false
})
it('ensures that early set and unset calls are replayed after the config is loaded from disk', () => {
atom.config.unset('foo.bar')
atom.config.set('foo.qux', 'boo')
expect(atom.config.get('foo.bar')).toBeUndefined()
expect(atom.config.get('foo.qux')).toBe('boo')
expect(atom.config.get('do.ray')).toBeUndefined()
advanceClock(100)
expect(savedSettings.length).toBe(0)
atom.config.resetUserSettings({
'*': {
foo: {
bar: 'baz'
},
do: {
ray: 'me'
}
}
})
advanceClock(100)
expect(savedSettings.length).toBe(1)
expect(atom.config.get('foo.bar')).toBeUndefined()
expect(atom.config.get('foo.qux')).toBe('boo')
expect(atom.config.get('do.ray')).toBe('me')
})
})
describe('project specific settings', () => {
describe('config.resetProjectSettings', () => {
it('gracefully handles invalid config objects', () => {
atom.config.resetProjectSettings({})
expect(atom.config.get('foo.bar')).toBeUndefined()
})
})
describe('config.get', () => {
const dummyPath = '/Users/dummy/path.json'
describe('project settings', () => {
it('returns a deep clone of the property value', () => {
atom.config.resetProjectSettings(
{ '*': { value: { array: [1, { b: 2 }, 3] } } },
dummyPath
)
const retrievedValue = atom.config.get('value')
retrievedValue.array[0] = 4
retrievedValue.array[1].b = 2.1
expect(atom.config.get('value')).toEqual({ array: [1, { b: 2 }, 3] })
})
it('properly gets project settings', () => {
atom.config.resetProjectSettings({ '*': { foo: 'wei' } }, dummyPath)
expect(atom.config.get('foo')).toBe('wei')
atom.config.resetProjectSettings(
{ '*': { foo: { bar: 'baz' } } },
dummyPath
)
expect(atom.config.get('foo.bar')).toBe('baz')
})
it('gets project settings with higher priority than regular settings', () => {
atom.config.set('foo', 'bar')
atom.config.resetProjectSettings({ '*': { foo: 'baz' } }, dummyPath)
expect(atom.config.get('foo')).toBe('baz')
})
it('correctly gets nested and scoped properties for project settings', () => {
expect(atom.config.set('foo.bar.str', 'global')).toBe(true)
expect(
atom.config.set('foo.bar.str', 'scoped', {
scopeSelector: '.source.js'
})
).toBe(true)
expect(atom.config.get('foo.bar.str')).toBe('global')
expect(
atom.config.get('foo.bar.str', { scope: ['.source.js'] })
).toBe('scoped')
})
it('returns a deep clone of the property value', () => {
atom.config.set('value', { array: [1, { b: 2 }, 3] })
const retrievedValue = atom.config.get('value')
retrievedValue.array[0] = 4
retrievedValue.array[1].b = 2.1
expect(atom.config.get('value')).toEqual({ array: [1, { b: 2 }, 3] })
})
it('gets scoped values correctly', () => {
atom.config.set('foo', 'bam', { scope: ['second'] })
expect(atom.config.get('foo', { scopeSelector: 'second' })).toBe(
'bam'
)
atom.config.resetProjectSettings(
{ '*': { foo: 'baz' }, second: { foo: 'bar' } },
dummyPath
)
expect(atom.config.get('foo', { scopeSelector: 'second' })).toBe(
'baz'
)
atom.config.clearProjectSettings()
expect(atom.config.get('foo', { scopeSelector: 'second' })).toBe(
'bam'
)
})
it('clears project settings correctly', () => {
atom.config.set('foo', 'bar')
expect(atom.config.get('foo')).toBe('bar')
atom.config.resetProjectSettings(
{ '*': { foo: 'baz' }, second: { foo: 'bar' } },
dummyPath
)
expect(atom.config.get('foo')).toBe('baz')
expect(atom.config.getSources().length).toBe(1)
atom.config.clearProjectSettings()
expect(atom.config.get('foo')).toBe('bar')
expect(atom.config.getSources().length).toBe(0)
})
})
})
describe('config.getAll', () => {
const dummyPath = '/Users/dummy/path.json'
it('gets settings in the same way .get would return them', () => {
atom.config.resetProjectSettings({ '*': { a: 'b' } }, dummyPath)
atom.config.set('a', 'f')
expect(atom.config.getAll('a')).toEqual([
{
scopeSelector: '*',
value: 'b'
}
])
})
})
})
})