@looker/api-explorer 0.9.19 → 0.9.25

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

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

package/src/state/settings/sagas.ts

@@ -0,0 +1,79 @@
+/*
+
+ 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 { takeEvery, call, put, select } from 'typed-redux-saga'
+
+import { getEnvAdaptor } from '@looker/extension-utils'
+import { StoreConstants } from '@looker/run-it'
+import type { RootState } from '../store'
+import { settingActions, defaultSettings } from './slice'
+
+/**
+ * Serializes state to local storage
+ */
+function* serializeToLocalStorageSaga() {
+  const adaptor = getEnvAdaptor()
+  const settings = yield* select((state: RootState) => ({
+    sdkLanguage: state.settings.sdkLanguage,
+  }))
+  adaptor.localStorageSetItem(
+    StoreConstants.LOCALSTORAGE_SETTINGS_KEY,
+    JSON.stringify(settings)
+  )
+}
+
+/**
+ * Returns default settings overridden with any persisted state in local storage
+ */
+async function deserializeLocalStorage() {
+  const adaptor = getEnvAdaptor()
+  const settings = await adaptor.localStorageGetItem(
+    StoreConstants.LOCALSTORAGE_SETTINGS_KEY
+  )
+  return settings
+    ? { ...defaultSettings, ...JSON.parse(settings) }
+    : defaultSettings
+}
+
+/**
+ * Initializes the store with default settings and existing persisted settings
+ */
+function* initSaga() {
+  const { initSettingsSuccessAction, initSettingsFailureAction } =
+    settingActions
+  try {
+    const settings = yield* call(deserializeLocalStorage)
+    yield* put(initSettingsSuccessAction(settings))
+  } catch (error: any) {
+    yield* put(initSettingsFailureAction(error))
+  }
+}
+
+export function* saga() {
+  const { initSettingsAction, setSdkLanguageAction } = settingActions
+
+  yield* takeEvery(initSettingsAction, initSaga)
+  yield* takeEvery(setSdkLanguageAction, serializeToLocalStorageSaga)
+}

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

@@ -23,14 +23,21 @@
  SOFTWARE.
 
  */
-import { getSelectedSdkLanguage } from './selectors'
-
-describe('settings selectors', () => {
-  test('getSelectedSdkLanguages returns selected sdk languages', () => {
-    const sdkLanguage = 'Kotlin'
-    const state = {
-      settings: { sdkLanguage },
-    }
-    expect(getSelectedSdkLanguage(state)).toEqual(sdkLanguage)
+import { createTestStore, preloadedState } from '../../test-utils'
+import { selectSdkLanguage, isInitialized } from './selectors'
+
+const testStore = createTestStore()
+
+describe('Settings selectors', () => {
+  const state = testStore.getState()
+
+  test('selectSdkLanguage selects', () => {
+    expect(selectSdkLanguage(state)).toEqual(
+      preloadedState.settings.sdkLanguage
+    )
+  })
+
+  test('isInitialized selects', () => {
+    expect(isInitialized(state)).toEqual(preloadedState.settings.initialized)
   })
 })

package/src/state/settings/selectors.ts

@@ -23,7 +23,18 @@
  SOFTWARE.
 
  */
-import { RootState } from '../store'
+import type { RootState } from '../store'
 
-export const getSelectedSdkLanguage = (state: RootState) =>
-  state.settings!.sdkLanguage
+const selectSettingsState = (state: RootState) => state.settings
+
+export const selectSdkLanguage = (state: RootState) =>
+  selectSettingsState(state).sdkLanguage
+
+export const selectSearchPattern = (state: RootState) =>
+  selectSettingsState(state).searchPattern
+
+export const selectSearchCriteria = (state: RootState) =>
+  selectSettingsState(state).searchCriteria
+
+export const isInitialized = (state: RootState) =>
+  selectSettingsState(state).initialized

package/src/state/settings/slice.ts

@@ -0,0 +1,94 @@
+/*
+
+ 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 { createSlice } from '@reduxjs/toolkit'
+import type { PayloadAction } from '@reduxjs/toolkit'
+import { createSliceHooks } from '@looker/redux'
+import type { SearchCriterionTerm } from '@looker/sdk-codegen'
+import { SearchAll, setToCriteria } from '@looker/sdk-codegen'
+
+import { saga } from './sagas'
+
+export interface UserDefinedSettings {
+  sdkLanguage: string
+}
+
+export interface SettingState extends UserDefinedSettings {
+  searchPattern: string
+  searchCriteria: SearchCriterionTerm[]
+  initialized: boolean
+  error?: Error
+}
+
+export const defaultSettings = {
+  sdkLanguage: 'Python',
+  searchPattern: '',
+  searchCriteria: setToCriteria(SearchAll) as SearchCriterionTerm[],
+}
+
+export const defaultSettingsState: SettingState = {
+  ...defaultSettings,
+  initialized: false,
+}
+
+type SetSearchPatternAction = Pick<SettingState, 'searchPattern'>
+type SetSdkLanguageAction = Pick<SettingState, 'sdkLanguage'>
+
+export type InitSuccessPayload = UserDefinedSettings
+
+export const settingsSlice = createSlice({
+  name: 'settings',
+  initialState: defaultSettingsState,
+  reducers: {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    initSettingsAction() {},
+    initSettingsSuccessAction(
+      state,
+      action: PayloadAction<InitSuccessPayload>
+    ) {
+      state.sdkLanguage = action.payload.sdkLanguage
+      state.initialized = true
+    },
+    initSettingsFailureAction(state, action: PayloadAction<Error>) {
+      state.error = action.payload
+      state.initialized = false
+    },
+    setSdkLanguageAction(state, action: PayloadAction<SetSdkLanguageAction>) {
+      state.sdkLanguage = action.payload.sdkLanguage
+    },
+    setSearchPatternAction(
+      state,
+      action: PayloadAction<SetSearchPatternAction>
+    ) {
+      state.searchPattern = action.payload.searchPattern
+    },
+  },
+})
+
+export const settingActions = settingsSlice.actions
+export const {
+  useActions: useSettingActions,
+  useStoreState: useSettingStoreState,
+} = createSliceHooks(settingsSlice, saga)

package/src/state/store.ts

@@ -23,11 +23,25 @@
  SOFTWARE.
 
  */
-
-import { createStore, Store } from 'redux'
-import { reducers } from './reducers'
-
-export type RootState = ReturnType<typeof reducers>
-
-export const configureStore = (preloadedState?: RootState): Store<RootState> =>
-  createStore(reducers, preloadedState)
+import { createStore } from '@looker/redux'
+
+import type { SettingState } from './settings'
+import { defaultSettingsState, settingsSlice } from './settings'
+import type { LodesState } from './lodes'
+import { lodesSlice, defaultLodesState } from './lodes'
+
+export const store = createStore({
+  preloadedState: {
+    settings: defaultSettingsState,
+    lodes: defaultLodesState,
+  },
+  reducer: {
+    settings: settingsSlice.reducer,
+    lodes: lodesSlice.reducer,
+  },
+})
+
+export interface RootState {
+  settings: SettingState
+  lodes: LodesState
+}

package/src/{reducers/search/actions.ts → test-data/declarations.ts}

@@ -23,20 +23,21 @@
  SOFTWARE.
 
  */
-
-import { SearchCriterionTerm } from '@looker/sdk-codegen'
-import { SearchAction } from './reducer'
-
-export const setPattern = (pattern: string): SearchAction => ({
-  type: 'SET_PATTERN',
-  payload: {
-    pattern,
+import type { IDeclarationMine } from '@looker/sdk-codegen'
+
+export const declarations: IDeclarationMine = {
+  commitHash: '1e9348b797c2f3760d03c1f94c60f18e534e8298',
+  remoteOrigin: 'https://github.com/looker-open-source/sdk-codegen',
+  types: {
+    FullLode: {
+      line: 40,
+      sourceFile: 'packages/api-explorer/src/utils/lodeUtils.ts',
+    },
   },
-})
-
-export const setCriteria = (criteria: SearchCriterionTerm[]): SearchAction => ({
-  type: 'SET_CRITERIA',
-  payload: {
-    criteria,
+  methods: {
+    getLoded: {
+      line: 45,
+      sourceFile: 'packages/api-explorer/src/utils/lodeUtils.ts',
+    },
   },
-})
+}

package/src/test-data/examples.ts

@@ -23,7 +23,7 @@
  SOFTWARE.
 
  */
-import { IExampleMine } from '@looker/sdk-codegen'
+import type { IExampleMine } from '@looker/sdk-codegen'
 
 // prettier-ignore
 export const examples: IExampleMine = {

package/src/test-data/index.ts

@@ -32,3 +32,4 @@ export {
   getLoadedSpecState,
 } from './specs'
 export { examples } from './examples'
+export * from './declarations'

package/src/test-data/specs.ts

@@ -23,7 +23,8 @@
  SOFTWARE.
 
  */
-import { ApiModel, SpecList } from '@looker/sdk-codegen'
+import type { SpecList } from '@looker/sdk-codegen'
+import { ApiModel } from '@looker/sdk-codegen'
 
 import { initDefaultSpecState } from '../reducers'
 

package/src/test-utils/index.ts

@@ -23,17 +23,6 @@
  SOFTWARE.
 
  */
-export {
-  renderWithSearch,
-  renderWithSearchAndRouter,
-} from './render_with_search'
-export {
-  renderWithLode,
-  renderWithReduxProviderAndLode,
-} from './render_with_lode'
-export { renderWithRouter, withRouter } from './router'
-export {
-  renderWithRouterAndReduxProvider,
-  renderWithReduxProvider,
-  withReduxProvider,
-} from './redux'
+export * from './lodes'
+export * from './router'
+export * from './redux'

package/src/{context/search/SearchContext.ts → test-utils/lodes.tsx}

@@ -23,20 +23,19 @@
  SOFTWARE.
 
  */
-
-import { createContext, Dispatch } from 'react'
-import { SearchState, SearchAction, defaultSearchState } from '../../reducers'
-
-interface SearchContextProps {
-  searchSettings: SearchState
-  setSearchSettings: Dispatch<SearchAction>
+import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
+import type { ReactElement } from 'react'
+import type { RenderOptions } from '@testing-library/react'
+import { renderWithTheme } from '@looker/components-test-utils'
+
+import { createTestStore, withReduxProvider } from './redux'
+
+export const renderWithLode = (
+  consumers: ReactElement<any>,
+  examples: IExampleMine,
+  declarations?: IDeclarationMine,
+  options?: Omit<RenderOptions, 'queries'>
+) => {
+  const store = createTestStore({ lodes: { examples, declarations } })
+  return renderWithTheme(withReduxProvider(consumers, store), options)
 }
-
-export const defaultSearchContextValue: SearchContextProps = {
-  searchSettings: defaultSearchState,
-  setSearchSettings: () => undefined,
-}
-
-export const SearchContext = createContext<SearchContextProps>(
-  defaultSearchContextValue
-)

package/src/test-utils/redux.tsx

@@ -23,49 +23,69 @@
  SOFTWARE.
 
  */
-import React, { ReactElement } from 'react'
+
+import type { ReactElement } from 'react'
+import React from 'react'
 import { Provider } from 'react-redux'
-import { Store } from 'redux'
+import type { Store } from 'redux'
 import { renderWithTheme } from '@looker/components-test-utils'
-import { RenderOptions } from '@testing-library/react'
-
-import { configureStore, RootState } from '../state'
-import { IApixEnvAdaptor, StandaloneEnvAdaptor } from '../utils'
-import { EnvAdaptorContext } from '../context'
-import { renderWithRouter } from '.'
+import type { RenderOptions } from '@testing-library/react'
+import { createStore } from '@looker/redux'
+import { BrowserAdaptor, registerEnvAdaptor } from '@looker/extension-utils'
+import { initRunItSdk } from '@looker/run-it'
 
-const defaultStore = configureStore()
+import type { LodesState, RootState, SettingState } from '../state'
+import {
+  settingsSlice,
+  defaultLodesState,
+  defaultSettingsState,
+  store as defaultStore,
+  lodesSlice,
+} from '../state'
+import { renderWithRouter } from './router'
 
 export const withReduxProvider = (
   consumers: ReactElement<any>,
-  store: Store<RootState> = defaultStore,
-  envAdaptor: IApixEnvAdaptor = new StandaloneEnvAdaptor()
+  store: Store<RootState> = defaultStore
 ) => {
-  return (
-    <Provider store={store}>
-      <EnvAdaptorContext.Provider value={{ envAdaptor }}>
-        {consumers}
-      </EnvAdaptorContext.Provider>
-    </Provider>
-  )
+  registerEnvAdaptor(new BrowserAdaptor(initRunItSdk()))
+  return <Provider store={store}>{consumers}</Provider>
 }
 
 export const renderWithReduxProvider = (
   consumers: ReactElement<any>,
   store?: Store<RootState>,
-  envAdaptor?: IApixEnvAdaptor,
   options?: Omit<RenderOptions, 'queries'>
-) => renderWithTheme(withReduxProvider(consumers, store, envAdaptor), options)
+) => renderWithTheme(withReduxProvider(consumers, store), options)
 
 export const renderWithRouterAndReduxProvider = (
   consumers: ReactElement<any>,
   initialEntries: string[] = ['/'],
   store?: Store<RootState>,
-  envAdaptor?: IApixEnvAdaptor,
   options?: Omit<RenderOptions, 'queries'>
 ) =>
-  renderWithRouter(
-    withReduxProvider(consumers, store, envAdaptor),
-    initialEntries,
-    options
-  )
+  renderWithRouter(withReduxProvider(consumers, store), initialEntries, options)
+
+export const preloadedState: RootState = {
+  settings: defaultSettingsState,
+  lodes: defaultLodesState,
+}
+
+type DeepPartial<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>
+}
+
+export const createTestStore = (overrides?: DeepPartial<RootState>) =>
+  createStore({
+    preloadedState: {
+      settings: {
+        ...preloadedState.settings,
+        ...overrides?.settings,
+      } as SettingState,
+      lodes: {
+        ...defaultLodesState,
+        ...overrides?.lodes,
+      } as LodesState,
+    },
+    reducer: { settings: settingsSlice.reducer, lodes: lodesSlice.reducer },
+  })

package/src/test-utils/router.tsx

@@ -24,9 +24,10 @@
 
  */
 
-import React, { ReactElement } from 'react'
+import type { ReactElement } from 'react'
+import React from 'react'
 import { MemoryRouter } from 'react-router-dom'
-import { RenderOptions } from '@testing-library/react'
+import type { RenderOptions } from '@testing-library/react'
 import { renderWithTheme } from '@looker/components-test-utils'
 
 export const withRouter = (

package/src/utils/index.ts

@@ -24,7 +24,12 @@
 
  */
 export { highlightHTML } from './highlight'
-export { buildMethodPath, buildTypePath, diffPath, oAuthPath } from './path'
+export {
+  buildPath,
+  buildMethodPath,
+  buildTypePath,
+  diffPath,
+  oAuthPath,
+} from './path'
 export { getLoded } from './lodeUtils'
 export { useWindowSize } from './useWindowSize'
-export * from './envAdaptor'

package/src/utils/lodeUtils.ts

@@ -24,7 +24,7 @@
 
  */
 
-import { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
+import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
 
 export const apixFilesHost = 'http://localhost:30000'
 
@@ -38,17 +38,17 @@ const fetchLode = async (lodeUrl: string) => {
 }
 
 interface FullLode {
-  examples: IExampleMine
+  examples?: IExampleMine
   declarations?: IDeclarationMine
 }
 
 export const getLoded = async (
-  examplesLodeUrl: string,
+  examplesLodeUrl?: string,
   declarationsLodeUrl?: string
 ): Promise<FullLode> => {
   // First try to load from the apix-files server
   let examples = await fetchLode(`${apixFilesHost}/examplesIndex.json`)
-  if (!examples) {
+  if (!examples && examplesLodeUrl) {
     examples = await fetchLode(examplesLodeUrl)
   }
 
@@ -57,9 +57,7 @@ export const getLoded = async (
     declarations = await fetchLode(declarationsLodeUrl)
   }
 
-  const lode: FullLode = {
-    examples: { commitHash: '', nuggets: {}, remoteOrigin: '', summaries: {} },
-  }
+  const lode: FullLode = { examples: undefined, declarations: undefined }
   if (examples) {
     lode.examples = JSON.parse(examples)
   }