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('when the first component of the scope descriptor matches a legacy scope alias', () => it('falls back to properties defined for the legacy scope if no value is found for the original scope descriptor', () => { atom.config.setLegacyScopeAliasForNewScope('javascript', '.source.js') atom.config.set('foo', 100, {scopeSelector: '.source.js'}) atom.config.set('foo', 200, {scopeSelector: 'javascript for_statement'}) expect(atom.config.get('foo', {scope: ['javascript', 'for_statement', 'identifier']})).toBe(200) expect(atom.config.get('foo', {scope: ['javascript', 'function', 'identifier']})).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('when the first component of the scope descriptor matches a legacy scope alias', () => it('includes the values defined for the legacy scope', () => { atom.config.setLegacyScopeAliasForNewScope('javascript', '.source.js') expect(atom.config.set('foo', 41)).toBe(true) expect(atom.config.set('foo', 42, {scopeSelector: 'javascript'})).toBe(true) expect(atom.config.set('foo', 43, {scopeSelector: '.source.js'})).toBe(true) expect(atom.config.getAll('foo', {scope: ['javascript']})).toEqual([ {scopeSelector: 'javascript', value: 42}, {scopeSelector: '.js.source', value: 43}, {scopeSelector: '*', value: 41} ]) }) ) }) 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}) }) }) }) 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' }]) }) }) }) })