@looker/api-explorer 0.9.22 → 0.9.27

package/src/{test-utils/render_with_lode.tsx → state/lodes/slice.ts}

@@ -23,47 +23,47 @@
  SOFTWARE.
 
  */
-
-import type { ReactElement } from 'react'
-import React from 'react'
-import type { RenderOptions } from '@testing-library/react'
-import type { Store } from 'redux'
-
-import { renderWithTheme } from '@looker/components-test-utils'
+import { createSliceHooks } from '@looker/redux'
 import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
-import { LodeContext } from '../context'
-import type { RootState } from '../state'
-import { withReduxProvider } from './redux'
+import type { PayloadAction } from '@reduxjs/toolkit'
+import { createSlice } from '@reduxjs/toolkit'
 
-const withLode = (
-  consumer: ReactElement<any>,
-  examples: IExampleMine,
+import { saga } from './sagas'
+
+export interface LodesState {
+  examples?: IExampleMine
   declarations?: IDeclarationMine
-) => {
-  return (
-    <LodeContext.Provider value={{ examples, declarations }}>
-      {consumer}
-    </LodeContext.Provider>
-  )
+  error?: Error
 }
 
-export const renderWithLode = (
-  component: ReactElement<any>,
-  examples: IExampleMine,
-  declarations?: IDeclarationMine,
-  options?: Omit<RenderOptions, 'queries'>
-) => {
-  return renderWithTheme(withLode(component, examples, declarations), options)
+export const defaultLodesState: LodesState = {
+  examples: undefined,
+  declarations: undefined,
 }
 
-export const renderWithReduxProviderAndLode = (
-  component: ReactElement<any>,
-  examples: IExampleMine,
-  declarations?: IDeclarationMine,
-  store?: Store<RootState>,
-  options?: Omit<RenderOptions, 'queries'>
-) =>
-  renderWithTheme(
-    withReduxProvider(withLode(component, examples, declarations), store),
-    options
-  )
+export interface InitPayload {
+  examplesLodeUrl?: string
+  declarationsLodeUrl?: string
+}
+
+type InitSuccessAction = LodesState
+
+export const lodesSlice = createSlice({
+  name: 'lodes',
+  initialState: defaultLodesState,
+  reducers: {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    initLodesAction(_state, _action: PayloadAction<InitPayload>) {},
+    initLodesSuccessAction(state, action: PayloadAction<InitSuccessAction>) {
+      state.examples = action.payload.examples
+      state.declarations = action.payload.declarations
+    },
+    initLodesFailureAction(state, action: PayloadAction<Error>) {
+      state.error = action.payload
+    },
+  },
+})
+
+export const lodeActions = lodesSlice.actions
+export const { useActions: useLodeActions, useStoreState: useLodesStoreState } =
+  createSliceHooks(lodesSlice, saga)

package/src/state/settings/sagas.spec.ts

@@ -24,11 +24,11 @@
 
  */
 import ReduxSagaTester from 'redux-saga-tester'
-import { registerTestEnvAdaptor } from '../../test-utils'
 
-import { EnvAdaptorConstants, getEnvAdaptor } from '../../utils'
+import { getEnvAdaptor, registerTestEnvAdaptor } from '@looker/extension-utils'
+import { StoreConstants } from '@looker/run-it'
 import * as sagas from './sagas'
-import { actions, defaultSettings, slice } from './slice'
+import { settingActions, defaultSettings, settingsSlice } from './slice'
 
 describe('Settings Sagas', () => {
   let sagaTester: ReduxSagaTester<any>
@@ -39,7 +39,7 @@ describe('Settings Sagas', () => {
     sagaTester = new ReduxSagaTester({
       initialState: { settings: { sdkLanguage: 'Go' } },
       reducers: {
-        settings: slice.reducer,
+        settings: settingsSlice.reducer,
       },
     })
     localStorage.clear()
@@ -47,7 +47,7 @@ describe('Settings Sagas', () => {
   })
 
   describe('setSdkLanguageSaga', () => {
-    const setSdkLanguageAction = actions.setSdkLanguageAction
+    const setSdkLanguageAction = settingActions.setSdkLanguageAction
 
     test('persists value sdkLanguage in localstorage', async () => {
       sagaTester.dispatch(setSdkLanguageAction({ sdkLanguage: 'Kotlin' }))
@@ -60,58 +60,62 @@ describe('Settings Sagas', () => {
         })
       )
       expect(localStorage.setItem).toHaveBeenLastCalledWith(
-        EnvAdaptorConstants.LOCALSTORAGE_SETTINGS_KEY,
+        StoreConstants.LOCALSTORAGE_SETTINGS_KEY,
         JSON.stringify({ sdkLanguage: 'Kotlin' })
       )
     })
   })
 
   describe('initSaga', () => {
-    const { initAction, initSuccessAction, initFailureAction } = actions
+    const {
+      initSettingsAction,
+      initSettingsSuccessAction,
+      initSettingsFailureAction,
+    } = settingActions
 
     test('sends initSuccess action with defaults on success if no persisted settings are found', async () => {
-      sagaTester.dispatch(initAction())
-      await sagaTester.waitFor('settings/initSuccessAction')
+      sagaTester.dispatch(initSettingsAction())
+      await sagaTester.waitFor('settings/initSettingsSuccessAction')
       const calledActions = sagaTester.getCalledActions()
       expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initAction())
+      expect(calledActions[0]).toEqual(initSettingsAction())
       expect(calledActions[1]).toEqual(
-        initSuccessAction({
+        initSettingsSuccessAction({
           ...defaultSettings,
         })
       )
     })
 
-    test('sends initSuccess action with persisted language on success', async () => {
+    test('sends initSettingsSuccessAction with persisted language on success', async () => {
       jest
         .spyOn(getEnvAdaptor(), 'localStorageGetItem')
         .mockResolvedValueOnce(JSON.stringify({ sdkLanguage: 'Go' }))
 
-      sagaTester.dispatch(initAction())
-      await sagaTester.waitFor('settings/initSuccessAction')
+      sagaTester.dispatch(initSettingsAction())
+      await sagaTester.waitFor('settings/initSettingsSuccessAction')
       const calledActions = sagaTester.getCalledActions()
       expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initAction())
+      expect(calledActions[0]).toEqual(initSettingsAction())
       expect(calledActions[1]).toEqual(
-        initSuccessAction({
+        initSettingsSuccessAction({
           ...defaultSettings,
           sdkLanguage: 'Go',
         })
       )
     })
 
-    test('sends initFailure action on error', async () => {
+    test('sends initSettingsFailureAction on error', async () => {
       const error = new Error('boom')
       jest
         .spyOn(getEnvAdaptor(), 'localStorageGetItem')
         .mockRejectedValueOnce(error)
 
-      sagaTester.dispatch(initAction())
-      await sagaTester.waitFor('settings/initFailureAction')
+      sagaTester.dispatch(initSettingsAction())
+      await sagaTester.waitFor('settings/initSettingsFailureAction')
       const calledActions = sagaTester.getCalledActions()
       expect(calledActions).toHaveLength(2)
-      expect(calledActions[0]).toEqual(initAction())
-      expect(calledActions[1]).toEqual(initFailureAction(error))
+      expect(calledActions[0]).toEqual(initSettingsAction())
+      expect(calledActions[1]).toEqual(initSettingsFailureAction(error))
     })
   })
 })

package/src/state/settings/sagas.ts

@@ -25,21 +25,21 @@
  */
 import { takeEvery, call, put, select } from 'typed-redux-saga'
 
-import { EnvAdaptorConstants, getEnvAdaptor } from '../../utils'
+import { getEnvAdaptor } from '@looker/extension-utils'
+import { StoreConstants } from '@looker/run-it'
 import type { RootState } from '../store'
-import { actions, defaultSettings } from './slice'
+import { settingActions, defaultSettings } from './slice'
 
 /**
  * Serializes state to local storage
  */
 function* serializeToLocalStorageSaga() {
-  const envAdaptor = getEnvAdaptor()
+  const adaptor = getEnvAdaptor()
   const settings = yield* select((state: RootState) => ({
     sdkLanguage: state.settings.sdkLanguage,
   }))
-  yield* call(
-    envAdaptor.localStorageSetItem,
-    EnvAdaptorConstants.LOCALSTORAGE_SETTINGS_KEY,
+  adaptor.localStorageSetItem(
+    StoreConstants.LOCALSTORAGE_SETTINGS_KEY,
     JSON.stringify(settings)
   )
 }
@@ -47,11 +47,10 @@ function* serializeToLocalStorageSaga() {
 /**
  * Returns default settings overridden with any persisted state in local storage
  */
-function* deserializeLocalStorage() {
-  const envAdaptor = getEnvAdaptor()
-  const settings = yield* call(
-    envAdaptor.localStorageGetItem,
-    EnvAdaptorConstants.LOCALSTORAGE_SETTINGS_KEY
+async function deserializeLocalStorage() {
+  const adaptor = getEnvAdaptor()
+  const settings = await adaptor.localStorageGetItem(
+    StoreConstants.LOCALSTORAGE_SETTINGS_KEY
   )
   return settings
     ? { ...defaultSettings, ...JSON.parse(settings) }
@@ -62,18 +61,19 @@ function* deserializeLocalStorage() {
  * Initializes the store with default settings and existing persisted settings
  */
 function* initSaga() {
-  const { initSuccessAction, initFailureAction } = actions
+  const { initSettingsSuccessAction, initSettingsFailureAction } =
+    settingActions
   try {
     const settings = yield* call(deserializeLocalStorage)
-    yield* put(initSuccessAction(settings))
+    yield* put(initSettingsSuccessAction(settings))
   } catch (error: any) {
-    yield* put(initFailureAction(error))
+    yield* put(initSettingsFailureAction(error))
   }
 }
 
 export function* saga() {
-  const { initAction, setSdkLanguageAction } = actions
+  const { initSettingsAction, setSdkLanguageAction } = settingActions
 
-  yield* takeEvery(initAction, initSaga)
+  yield* takeEvery(initSettingsAction, initSaga)
   yield* takeEvery(setSdkLanguageAction, serializeToLocalStorageSaga)
 }

package/src/state/settings/selectors.spec.ts

@@ -23,13 +23,9 @@
  SOFTWARE.
 
  */
-import { createTestStore } from '../../test-utils'
+import { createTestStore, preloadedState } from '../../test-utils'
 import { selectSdkLanguage, isInitialized } from './selectors'
 
-const preloadedState = {
-  settings: { initialized: false, sdkLanguage: 'Python' },
-}
-
 const testStore = createTestStore()
 
 describe('Settings selectors', () => {

package/src/state/settings/selectors.ts

@@ -25,16 +25,16 @@
  */
 import type { RootState } from '../store'
 
-const getSettingsState = (state: RootState) => state.settings
+const selectSettingsState = (state: RootState) => state.settings
 
 export const selectSdkLanguage = (state: RootState) =>
-  getSettingsState(state).sdkLanguage
+  selectSettingsState(state).sdkLanguage
 
 export const selectSearchPattern = (state: RootState) =>
-  getSettingsState(state).searchPattern
+  selectSettingsState(state).searchPattern
 
 export const selectSearchCriteria = (state: RootState) =>
-  getSettingsState(state).searchCriteria
+  selectSettingsState(state).searchCriteria
 
 export const isInitialized = (state: RootState) =>
-  getSettingsState(state).initialized
+  selectSettingsState(state).initialized

package/src/state/settings/slice.ts

@@ -58,17 +58,20 @@ type SetSdkLanguageAction = Pick<SettingState, 'sdkLanguage'>
 
 export type InitSuccessPayload = UserDefinedSettings
 
-export const slice = createSlice({
+export const settingsSlice = createSlice({
   name: 'settings',
   initialState: defaultSettingsState,
   reducers: {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    initAction() {},
-    initSuccessAction(state, action: PayloadAction<InitSuccessPayload>) {
+    initSettingsAction() {},
+    initSettingsSuccessAction(
+      state,
+      action: PayloadAction<InitSuccessPayload>
+    ) {
       state.sdkLanguage = action.payload.sdkLanguage
       state.initialized = true
     },
-    initFailureAction(state, action: PayloadAction<Error>) {
+    initSettingsFailureAction(state, action: PayloadAction<Error>) {
       state.error = action.payload
       state.initialized = false
     },
@@ -84,6 +87,8 @@ export const slice = createSlice({
   },
 })
 
-export const actions = slice.actions
-export const { useActions, useStoreState: useSettingsStoreState } =
-  createSliceHooks(slice, saga)
+export const settingActions = settingsSlice.actions
+export const {
+  useActions: useSettingActions,
+  useStoreState: useSettingStoreState,
+} = createSliceHooks(settingsSlice, saga)

package/src/{context/lode → state/specs}/index.ts

@@ -23,4 +23,5 @@
  SOFTWARE.
 
  */
-export { defaultLodeContextValue, LodeContext } from './LodeContext'
+export * from './selectors'
+export * from './slice'

package/src/state/specs/sagas.spec.ts

@@ -0,0 +1,135 @@
+/*
+
+ MIT License
+
+ Copyright (c) 2021 Looker Data Sciences, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+ */
+import ReduxSagaTester from 'redux-saga-tester'
+import { registerTestEnvAdaptor } from '@looker/extension-utils'
+import { initRunItSdk } from '@looker/run-it'
+import cloneDeep from 'lodash/cloneDeep'
+import { ApixAdaptor } from '../../utils'
+
+import { getLoadedSpecs } from '../../test-data'
+import { specActions, specsSlice } from './slice'
+import * as sagas from './sagas'
+
+describe('Specs Sagas', () => {
+  let sagaTester: ReduxSagaTester<any>
+  const adaptor = new ApixAdaptor(initRunItSdk(), '')
+  registerTestEnvAdaptor(adaptor)
+  const specState = getLoadedSpecs()
+  const mockError = new Error('boom')
+
+  beforeEach(() => {
+    jest.resetAllMocks()
+    sagaTester = new ReduxSagaTester({
+      initialState: { specs: { specs: specState } },
+      reducers: {
+        specs: specsSlice.reducer,
+      },
+    })
+    sagaTester.start(sagas.saga)
+  })
+
+  describe('initSaga', () => {
+    const { initSpecsAction, initSpecsFailureAction, initSpecsSuccessAction } =
+      specActions
+
+    it('sends initSpecsFailureAction on error', async () => {
+      jest.spyOn(adaptor, 'fetchSpecList').mockRejectedValueOnce(mockError)
+
+      sagaTester.dispatch(initSpecsAction({ specKey: null }))
+      await sagaTester.waitFor('specs/initSpecsFailureAction')
+      const calledActions = sagaTester.getCalledActions()
+      expect(calledActions).toHaveLength(2)
+      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }))
+      expect(calledActions[1]).toEqual(initSpecsFailureAction(mockError))
+    })
+
+    it('sends initSpecsSuccessAction on success', async () => {
+      // fetchSpecList returns the test specs
+      jest
+        .spyOn(adaptor, 'fetchSpecList')
+        .mockResolvedValueOnce(cloneDeep(specState))
+
+      const currentSpec = specState['3.1']
+      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(currentSpec!)
+
+      // expected state is all the specs with the current spec containing the ApiModel
+      const expected = cloneDeep(specState)
+      expected[currentSpec.key] = currentSpec
+
+      sagaTester.dispatch(initSpecsAction({ specKey: null }))
+      await sagaTester.waitFor('specs/initSpecsSuccessAction')
+      const calledActions = sagaTester.getCalledActions()
+      expect(calledActions).toHaveLength(2)
+      expect(calledActions[0]).toEqual(initSpecsAction({ specKey: null }))
+      expect(calledActions[1]).toEqual(
+        initSpecsSuccessAction({
+          specs: expected,
+          currentSpecKey: currentSpec.key,
+        })
+      )
+    })
+  })
+
+  describe('setCurrentSpecSaga', () => {
+    const {
+      setCurrentSpecAction,
+      setCurrentSpecSuccessAction,
+      setCurrentSpecFailureAction,
+    } = specActions
+    const spec = specState['4.0']
+
+    it('sends setCurrentSpecSuccessAction on success', async () => {
+      jest.spyOn(adaptor, 'fetchSpec').mockResolvedValueOnce(spec)
+
+      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }))
+      await sagaTester.waitFor('specs/setCurrentSpecAction')
+      const calledActions = sagaTester.getCalledActions()
+      expect(calledActions).toHaveLength(2)
+      expect(calledActions[0]).toEqual(
+        setCurrentSpecAction({ currentSpecKey: spec.key })
+      )
+      expect(calledActions[1]).toEqual(
+        setCurrentSpecSuccessAction({
+          api: spec.api!,
+          currentSpecKey: spec.key,
+        })
+      )
+    })
+
+    it('sends setCurrentSpecFailureAction on failure', async () => {
+      jest.spyOn(adaptor, 'fetchSpec').mockRejectedValueOnce(mockError)
+
+      sagaTester.dispatch(setCurrentSpecAction({ currentSpecKey: spec.key }))
+      await sagaTester.waitFor('specs/setCurrentSpecAction')
+      const calledActions = sagaTester.getCalledActions()
+      expect(calledActions).toHaveLength(2)
+      expect(calledActions[0]).toEqual(
+        setCurrentSpecAction({ currentSpecKey: spec.key })
+      )
+      expect(calledActions[1]).toEqual(setCurrentSpecFailureAction(mockError))
+    })
+  })
+})

package/src/state/specs/sagas.ts

@@ -0,0 +1,81 @@
+/*
+
+ MIT License
+
+ Copyright (c) 2021 Looker Data Sciences, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+ */
+import type { SpecItem, SpecList } from '@looker/sdk-codegen'
+import { call, put, takeEvery, select } from 'typed-redux-saga'
+import type { PayloadAction } from '@reduxjs/toolkit'
+
+import { getApixAdaptor } from '../../utils'
+import type { RootState } from '../store'
+import type { InitSpecsAction, SetCurrentSpecAction } from './slice'
+import { specActions } from './slice'
+
+function* initSaga(action: PayloadAction<InitSpecsAction>) {
+  const { initSpecsSuccessAction, initSpecsFailureAction } = specActions
+  const adaptor = getApixAdaptor()
+
+  try {
+    const specs: SpecList = yield* call([adaptor, 'fetchSpecList'])
+    let currentSpecKey = action.payload.specKey
+    if (!currentSpecKey) {
+      currentSpecKey = Object.values(specs).find(
+        (spec) => spec.status === 'current'
+      )!.key
+    }
+    const spec = yield* call([adaptor, 'fetchSpec'], specs[currentSpecKey])
+    specs[currentSpecKey] = spec
+    yield* put(initSpecsSuccessAction({ specs, currentSpecKey }))
+  } catch (error: any) {
+    yield* put(initSpecsFailureAction(new Error(error.message)))
+  }
+}
+
+function* setCurrentSpecSaga(action: PayloadAction<SetCurrentSpecAction>) {
+  const { setCurrentSpecSuccessAction, setCurrentSpecFailureAction } =
+    specActions
+  const adaptor = getApixAdaptor()
+  const spec: SpecItem = yield* select(
+    (state: RootState) => state.specs.specs[action.payload.currentSpecKey]
+  )
+
+  try {
+    const newSpec = yield* call([adaptor, 'fetchSpec'], spec)
+    yield* put(
+      setCurrentSpecSuccessAction({
+        api: newSpec.api!,
+        currentSpecKey: action.payload.currentSpecKey,
+      })
+    )
+  } catch (error: any) {
+    yield put(setCurrentSpecFailureAction(new Error(error.message)))
+  }
+}
+
+export function* saga() {
+  const { initSpecsAction, setCurrentSpecAction } = specActions
+
+  yield* takeEvery(initSpecsAction, initSaga)
+  yield* takeEvery(setCurrentSpecAction, setCurrentSpecSaga)
+}

package/src/{test-utils/envAdaptor.ts → state/specs/selectors.ts}

@@ -23,9 +23,15 @@
  SOFTWARE.
 
  */
-import type { IApixEnvAdaptor } from '../utils'
-import { registerEnvAdaptor, StandaloneEnvAdaptor } from '../utils'
+import type { SpecItem } from '@looker/sdk-codegen'
 
-export const registerTestEnvAdaptor = (envAdaptor?: IApixEnvAdaptor) => {
-  registerEnvAdaptor(envAdaptor || new StandaloneEnvAdaptor())
+import type { RootState } from '../store'
+
+const selectSpecsState = (state: RootState) => state.specs
+
+export const selectSpecs = (state: RootState) => selectSpecsState(state).specs
+
+export const selectCurrentSpec = (state: RootState): SpecItem => {
+  const specState = selectSpecsState(state)
+  return specState.specs[specState.currentSpecKey]
 }