jest.mock('../layouts/layouts', () => {
  const { schema } = require('@kbn/config-schema');
  return {
    Layouts: {
      configSchema: schema.object({ kind: schema.literal('mock') }),
      create: mockCreateLayout,
    },
  };
});

test('re-validate config when updated', async () => {
  const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'value' }));

  const configService = new ConfigService(config$, defaultEnv, logger);
  configService.setSchema('key', schema.string());

  const valuesReceived: any[] = [];
  await configService.atPath('key').subscribe(
    value => {
      valuesReceived.push(value);
    },
    error => {
      valuesReceived.push(error);
    }
  );

  config$.next(new ObjectToConfigAdapter({ key: 123 }));

  await expect(valuesReceived).toMatchInlineSnapshot(`
Array [
  "value",
  [Error: [key]: expected value of type [string] but got [number]],
]
`);
});

  it('reads config schema from plugin', () => {
    const pluginSchema = schema.any();
    jest.doMock(
      'plugin-with-schema/server',
      () => ({
        config: {
          schema: pluginSchema,
        },
      }),
      { virtual: true }
    );
    const manifest = createPluginManifest();
    const plugin = new PluginWrapper(
      'plugin-with-schema',
      manifest,
      createPluginInitializerContext(coreContext, manifest)
    );

    expect(plugin.getConfigSchema()).toBe(pluginSchema);
  });

test('`setup` registers plugin config schema in config service', async () => {
  const configSchema = schema.string();
  jest.spyOn(configService, 'setSchema').mockImplementation(() => Promise.resolve());
  jest.doMock(
    join('path-with-schema', 'server'),
    () => ({
      config: {
        schema: configSchema,
      },
    }),
    {
      virtual: true,
    }
  );
  mockDiscover.mockReturnValue({
    error$: from([]),
    plugin$: from([
      new PluginWrapper(
        'path-with-schema',
        {
          id: 'some-id',
          version: 'some-version',
          configPath: 'path',
          kibanaVersion: '7.0.0',
          requiredPlugins: [],
          optionalPlugins: [],
          server: true,
          ui: true,
        },
        { logger } as any
      ),
    ]),
  });
  await pluginsService.setup(setupDeps);
  expect(configService.setSchema).toBeCalledWith('path', configSchema);
});

 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import { map, mergeMap } from 'rxjs/operators';
import { schema, TypeOf } from '@kbn/config-schema';

import { CoreSetup, CoreStart, Logger, PluginInitializerContext, PluginName } from 'kibana/server';

export const config = {
  schema: schema.object({
    secret: schema.string({ defaultValue: 'Not really a secret :/' }),
  }),
};

type ConfigType = TypeOf<typeof config.schema>;

class Plugin {
  private readonly log: Logger;

  constructor(private readonly initializerContext: PluginInitializerContext) {
    this.log = this.initializerContext.logger.get();
  }

  public setup(core: CoreSetup, deps: Record<PluginName, unknown>) {
    this.log.debug(
      `Setting up TestBed with core contract [${Object.keys(core)}] and deps [${Object.keys(deps)}]`