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", () => {
      afterEach(() => {
        atom.project.replace(null);
      });

      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);
      })

      it(`ignores project-specific settings unless specified in the "sources" option`, () => {
        atom.config.set('x.y', 1);
        atom.config.set('u.v', 5);

        atom.project.replace({
          originPath: 'TEST',
          paths: atom.project.getPaths(),
          config: {
            "*": {
              "x": {
                "y": 4
              }
            }
          }
        });

        expect(
          atom.config.get('x.y', { sources: [atom.config.mainSource] })
        ).toBe(1);
        expect(
          atom.config.get('x.y', { sources: [atom.config.mainSource, atom.config.projectFile] })
        ).toBe(4);

        expect(
          atom.config.get('x.y', { sources: [atom.config.projectFile] })
        ).toBe(4);

        expect(
          atom.config.get('u.v', {
            sources: [atom.config.projectFile],
            excludeSources: [atom.config.mainSource]
          })
        ).toBeUndefined();
      });
    });


    describe("when an 'excludeSources' option is specified", () => {
      afterEach(() => {
        atom.project.replace(null);
      });

      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);
      });

      it("ignores the project-specific source when 'excludeSources' tells it to", () => {
        atom.config.set('x.y', 1);

        atom.project.replace({
          originPath: 'TEST',
          paths: atom.project.getPaths(),
          config: {
            "*": {
              "x": {
                "y": 4
              }
            }
          }
        });

        expect( atom.config.get('x.y') ).toBe(4);
        expect(
          atom.config.get('x.y', { excludeSources: [atom.config.projectFile] })
        ).toBe(1);
      });
    });

    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'
          }
        ]);
      });
    });
  });
});