feat: wip

Author: ijsnow

src/extension/scripts/background.tsx

@@ -162,7 +162,7 @@ permissions.onRemoved(permissions => {
     })
 })
 
-// Ensure access tokens are in storage and they are in the correct shape.
+// Ensure access tokens are in storage and they are in the correct shape.jj
 storage.addSyncMigration((items, set, remove) => {
     if (!items.accessTokens) {
         set({ accessTokens: {} })

src/libs/options/OptionsContainer.test.tsx

@@ -0,0 +1,58 @@
+import { assert } from 'chai'
+import { describe, it } from 'mocha'
+import * as React from 'react'
+import { render } from 'react-testing-library'
+import { noop, Observable, of } from 'rxjs'
+import sinon from 'sinon'
+import { FeatureFlags } from '../../browser/types'
+import { OptionsContainer } from './OptionsContainer'
+
+describe('OptionsContainer', () => {
+    const stubGetConfigurableSettings = () => new Observable<Partial<FeatureFlags>>()
+    const stubSetConfigurableSettings = (settings: Observable<Partial<FeatureFlags>>) =>
+        new Observable<Partial<FeatureFlags>>()
+    const stub
+
+    it('checks the connection status when it renders', () => {
+        const fetchSiteSpy = sinon.spy()
+        const fetchSite = (url: string) => {
+            fetchSiteSpy(url)
+
+            return of(undefined)
+        }
+
+        render(
+            <OptionsContainer
+                sourcegraphURL={'url'}
+                fetchSite={fetchSite}
+                setSourcegraphURL={noop}
+                getConfigurableSettings={stubGetConfigurableSettings}
+                setConfigurableSettings={stubSetConfigurableSettings}
+            />
+        )
+
+        assert.isTrue(fetchSiteSpy.calledOnceWith('url'))
+    })
+
+    it('handles when an error is thrown checking the site connection', () => {
+        const fetchSite = () => {
+            throw new Error('no site, woops')
+        }
+
+        try {
+            render(
+                <OptionsContainer
+                    sourcegraphURL={'url'}
+                    fetchSite={fetchSite}
+                    setSourcegraphURL={noop}
+                    getConfigurableSettings={stubGetConfigurableSettings}
+                    setConfigurableSettings={stubSetConfigurableSettings}
+                />
+            )
+        } catch (err) {
+            throw new Error("shouldn't be hit")
+        }
+    })
+
+    it('creates a token when no token exists after connection check', () => {})
+})

src/libs/options/OptionsContainer.tsx

@@ -1,87 +1,132 @@
+import { propertyIsDefined } from '@sourcegraph/codeintellify/lib/helpers'
 import * as React from 'react'
-import { of, Subject, Subscription } from 'rxjs'
-import { catchError, map, switchMap, tap } from 'rxjs/operators'
+import { Observable, of, Subject, Subscription } from 'rxjs'
+import { catchError, filter, map, switchMap } from 'rxjs/operators'
 import { getExtensionVersionSync } from '../../browser/runtime'
-import { ERAUTHREQUIRED, isErrorLike } from '../../shared/backend/errors'
-import { fetchSite } from '../../shared/backend/server'
-import { sourcegraphUrl } from '../../shared/util/context'
+import { AccessToken, FeatureFlags } from '../../browser/types'
+import { ERAUTHREQUIRED, ErrorLike, isErrorLike } from '../../shared/backend/errors'
+import { GQL } from '../../types/gqlschema'
 import { OptionsMenu, OptionsMenuProps } from './Menu'
 import { ConnectionErrors } from './ServerURLForm'
-import { getConfigurableSettings, setConfigurabelSettings, setSourcegraphURL } from './settings'
+
+export interface OptionsContainerProps {
+    sourcegraphURL: string
+
+    fetchSite: (url: string) => Observable<void>
+    fetchCurrentUser: (useToken: boolean) => Observable<GQL.IUser | undefined>
+
+    setSourcegraphURL: (url: string) => void
+    getConfigurableSettings: () => Observable<Partial<FeatureFlags>>
+    setConfigurableSettings: (settings: Observable<Partial<FeatureFlags>>) => Observable<Partial<FeatureFlags>>
+
+    createAccessToken: (url: string) => Observable<AccessToken>
+    getAccessToken: (url: string) => Observable<AccessToken | undefined>
+    setAccessToken: (url: string) => (tokens: Observable<AccessToken>) => Observable<AccessToken>
+    fetchAccessTokenIDs: (url: string) => Observable<Pick<AccessToken, 'id'>[]>
+}
 
 interface OptionsContainerState
     extends Pick<
             OptionsMenuProps,
             'isSettingsOpen' | 'status' | 'sourcegraphURL' | 'settings' | 'settingsHaveChanged' | 'connectionError'
         > {}
 
-export class OptionsContainer extends React.Component<{}, OptionsContainerState> {
-    public state: OptionsContainerState = {
-        status: 'connecting',
-        sourcegraphURL: sourcegraphUrl,
-        isSettingsOpen: false,
-        settingsHaveChanged: false,
-        settings: {},
-    }
-
+export class OptionsContainer extends React.Component<OptionsContainerProps, OptionsContainerState> {
     private version = getExtensionVersionSync()
 
     private urlUpdates = new Subject<string>()
     private settingsSaves = new Subject<any>()
 
     private subscriptions = new Subscription()
 
-    constructor(props: {}) {
+    constructor(props: OptionsContainerProps) {
         super(props)
 
+        this.state = {
+            status: 'connecting',
+            sourcegraphURL: props.sourcegraphURL,
+            isSettingsOpen: false,
+            settingsHaveChanged: false,
+            settings: {},
+            connectionError: undefined,
+        }
+
+        const fetchingSite: Observable<string | ErrorLike> = this.urlUpdates.pipe(
+            switchMap(url => this.props.fetchSite(url).pipe(map(() => url))),
+            catchError(err => of(err))
+        )
+
         this.subscriptions.add(
-            this.urlUpdates
+            fetchingSite.subscribe(res => {
+                let url = ''
+
+                if (isErrorLike(res)) {
+                    this.setState({
+                        status: 'error',
+                        connectionError:
+                            res.code === ERAUTHREQUIRED ? ConnectionErrors.AuthError : ConnectionErrors.UnableToConnect,
+                    })
+                    url = this.state.sourcegraphURL
+                } else {
+                    this.setState({ status: 'connected' })
+                    url = res
+                }
+
+                props.setSourcegraphURL(url)
+            })
+        )
+
+        this.subscriptions.add(
+            // Ensure the site is valid.
+            fetchingSite
                 .pipe(
-                    tap(a => {
-                        console.log('a', a)
-                    }),
-                    switchMap(url => fetchSite(url).pipe(map(() => url))),
-                    catchError(err => of(err))
+                    filter(urlOrError => !isErrorLike(urlOrError)),
+                    map(urlOrError => urlOrError as string),
+                    // Get the access token for this server if we have it.
+                    switchMap(url => this.props.getAccessToken(url).pipe(map(token => ({ token, url })))),
+                    switchMap(({ url, token }) =>
+                        this.props.fetchCurrentUser(false).pipe(map(user => ({ user, token, url })))
+                    ),
+                    filter(propertyIsDefined('user')),
+                    // Get the IDs for all access tokens for the user.
+                    switchMap(({ token, user, url }) =>
+                        this.props
+                            .fetchAccessTokenIDs(user.id)
+                            .pipe(map(usersTokenIDs => ({ usersTokenIDs, user, token, url })))
+                    ),
+                    // Make sure the token still exists on the server. If it
+                    // does exits, use it, otherwise create a new one.
+                    switchMap(({ user, token, usersTokenIDs, url }) => {
+                        const tokenExists = token && usersTokenIDs.map(({ id }) => id).includes(token.id)
+
+                        return token && tokenExists
+                            ? of(token)
+                            : this.props.createAccessToken(user.id).pipe(this.props.setAccessToken(url))
+                    })
                 )
-                .subscribe(res => {
-                    let url = ''
-
-                    if (isErrorLike(res)) {
-                        this.setState({
-                            status: 'error',
-                            connectionError:
-                                res.code === ERAUTHREQUIRED
-                                    ? ConnectionErrors.AuthError
-                                    : ConnectionErrors.UnableToConnect,
-                        })
-                        url = this.state.sourcegraphURL
-                    } else {
-                        this.setState({ status: 'connected' })
-                        url = res
-                    }
-
-                    console.log(res, url)
-
-                    setSourcegraphURL(url)
+                .subscribe(() => {
+                    // We don't need to do anything with the token now. We just
+                    // needed to ensure we had one saved.
                 })
         )
 
         this.subscriptions.add(
-            this.settingsSaves.pipe(switchMap(settings => setConfigurabelSettings(settings))).subscribe(settings => {
-                this.setState({
-                    settings,
-                    settingsHaveChanged: false,
+            this.settingsSaves
+                .pipe(switchMap(settings => props.setConfigurableSettings(settings)))
+                .subscribe(settings => {
+                    this.setState({
+                        settings,
+                        settingsHaveChanged: false,
+                    })
                 })
-            })
         )
     }
 
     public componentDidMount(): void {
-        getConfigurableSettings().subscribe(settings => {
+        this.props.getConfigurableSettings().subscribe(settings => {
             this.setState({ settings })
         })
 
-        console.log('next url')
         this.urlUpdates.next(this.state.sourcegraphURL)
     }
 
@@ -108,7 +153,6 @@ export class OptionsContainer extends React.Component<{}, OptionsContainerState>
     }
 
     private handleURLSubmit = () => {
-        console.log('submitted', this.state.sourcegraphURL)
         this.urlUpdates.next(this.state.sourcegraphURL)
     }
 

src/libs/options/ServerURLForm.test.tsx

@@ -2,17 +2,13 @@ import { assert, expect } from 'chai'
 import { describe, it } from 'mocha'
 import * as React from 'react'
 import { cleanup, fireEvent, render } from 'react-testing-library'
-import { EMPTY, merge, of, Subject } from 'rxjs'
+import { EMPTY, merge, noop, of, Subject } from 'rxjs'
 import { switchMap, tap } from 'rxjs/operators'
 import { TestScheduler } from 'rxjs/testing'
-import * as sinon from 'sinon'
+import sinon from 'sinon'
 
 import { ServerURLForm, ServerURLFormProps } from './ServerURLForm'
 
-const noop = () => {
-    /* noop */
-}
-
 describe('ServerURLForm', () => {
     after(cleanup)