chore(prevent): Rename codecov routes to prevent (#97485)

This PR aims to change all the routes that were /codecov/ to /prevent/
as well as updating a bunch of consts that mentioned codecov when they
probably should have been named prevent. Wanted to do this sooner rather
than later to avoid an ever increasing diff.

Mostly just find and replace with cursor, had to be a little surgical
with the existing codecov integration items just because that actually
_was_ codecov stuff and not prevent



Closes
https://linear.app/getsentry/issue/CCMRG-1487/rename-codecov-routes-to-prevent



<!--

  Sentry employees and contractors can delete or ignore the following.

-->

### Legal Boilerplate

Look, I get it. The entity doing business as "Sentry" was incorporated
in the State of Delaware in 2015 as Functional Software, Inc. and is
gonna need some rights from me in order to utilize my contributions in
this here PR. So here's the deal: I retain all rights, title and
interest in and to my contributions, and by keeping this boilerplate
intact I confirm that Sentry can use, modify, copy, and redistribute my
contributions, under Sentry's choice of terms.

Author: ajay-sentry

knip.config.ts

@@ -17,8 +17,8 @@ const productionEntryPoints = [
   // this is imported with require.context
   'static/app/data/forms/*.tsx',
   // --- we should be able to get rid of those: ---
-  // todo codecov has unused code from the migration
-  'static/app/{components,views}/codecov/**/*.{js,mjs,ts,tsx}',
+  // Prevent exception until we build out coverage
+  'static/app/components/prevent/virtualRenderers/**/*.{js,ts,tsx}',
   // todo we currently keep all icons
   'static/app/icons/**/*.{js,mjs,ts,tsx}',
   // todo find out how chartcuterie works

static/app/components/codecov/context/codecovContext.tsx

@@ -2,13 +2,13 @@ import {useCallback, useEffect, useMemo, useState} from 'react';
 import styled from '@emotion/styled';
 import debounce from 'lodash/debounce';
 
-import {useInfiniteRepositoryBranches} from 'sentry/components/codecov/branchSelector/useInfiniteRepositoryBranches';
-import {useCodecovContext} from 'sentry/components/codecov/context/codecovContext';
 import {Button} from 'sentry/components/core/button';
 import type {SelectOption} from 'sentry/components/core/compactSelect';
 import {CompactSelect} from 'sentry/components/core/compactSelect';
 import {Flex} from 'sentry/components/core/layout';
 import DropdownButton from 'sentry/components/dropdownButton';
+import {useInfiniteRepositoryBranches} from 'sentry/components/prevent/branchSelector/useInfiniteRepositoryBranches';
+import {usePreventContext} from 'sentry/components/prevent/context/preventContext';
 import {t} from 'sentry/locale';
 import {space} from 'sentry/styles/space';
 
@@ -17,8 +17,8 @@ import {IconBranch} from './iconBranch';
 export const ALL_BRANCHES = 'All Branches';
 
 export function BranchSelector() {
-  const {branch, integratedOrgId, repository, codecovPeriod, changeContextValue} =
-    useCodecovContext();
+  const {branch, integratedOrgId, repository, preventPeriod, changeContextValue} =
+    usePreventContext();
   const [searchValue, setSearchValue] = useState<string | undefined>();
   const {data} = useInfiniteRepositoryBranches({term: searchValue});
   const branches = data.branches;
@@ -29,11 +29,11 @@ export function BranchSelector() {
       changeContextValue({
         integratedOrgId,
         repository,
-        codecovPeriod,
+        preventPeriod,
         branch: selectedOption.value,
       });
     },
-    [changeContextValue, integratedOrgId, repository, codecovPeriod]
+    [changeContextValue, integratedOrgId, repository, preventPeriod]
   );
 
   const handleOnSearch = useMemo(

static/app/components/codecov/branchSelector/branchSelector.tsx renamed to static/app/components/prevent/branchSelector/branchSelector.tsx

@@ -1,7 +1,7 @@
 import {useMemo} from 'react';
 
 import type {ApiResult} from 'sentry/api';
-import {useCodecovContext} from 'sentry/components/codecov/context/codecovContext';
+import {usePreventContext} from 'sentry/components/prevent/context/preventContext';
 import {
   fetchDataQuery,
   type InfiniteData,
@@ -33,7 +33,7 @@ type Props = {
 };
 
 export function useInfiniteRepositoryBranches({term}: Props) {
-  const {integratedOrgId, repository} = useCodecovContext();
+  const {integratedOrgId, repository} = usePreventContext();
   const organization = useOrganization();
 
   const {data, ...rest} = useInfiniteQuery<

static/app/components/codecov/branchSelector/iconBranch.tsx renamed to static/app/components/prevent/branchSelector/iconBranch.tsx

@@ -1,16 +1,16 @@
 import {useCallback} from 'react';
 import {useSearchParams} from 'react-router-dom';
 
-import {ALL_BRANCHES} from 'sentry/components/codecov/branchSelector/branchSelector';
+import {ALL_BRANCHES} from 'sentry/components/prevent/branchSelector/branchSelector';
 import type {
-  CodecovContextData,
-  CodecovContextDataParams,
-} from 'sentry/components/codecov/context/codecovContext';
-import {CodecovContext} from 'sentry/components/codecov/context/codecovContext';
+  PreventContextData,
+  PreventContextDataParams,
+} from 'sentry/components/prevent/context/preventContext';
+import {PreventContext} from 'sentry/components/prevent/context/preventContext';
 import {useLocalStorageState} from 'sentry/utils/useLocalStorageState';
 import useOrganization from 'sentry/utils/useOrganization';
 
-type CodecovQueryParamsProviderProps = {
+type PreventQueryParamsProviderProps = {
   children?: NonNullable<React.ReactNode>;
 };
 
@@ -20,25 +20,25 @@ type Org = {
 };
 
 type LocalStorageState = Record<string, Org> & {
-  codecovPeriod?: string;
   lastVisitedOrgId?: string;
+  preventPeriod?: string;
 };
 
 const VALUES_TO_RESET = ['repository', 'branch', 'testSuites'];
 
-export default function CodecovQueryParamsProvider({
+export default function PreventQueryParamsProvider({
   children,
-}: CodecovQueryParamsProviderProps) {
+}: PreventQueryParamsProviderProps) {
   const organization = useOrganization();
   const initialLocalStorageState: LocalStorageState = {};
   const [localStorageState, setLocalStorageState] = useLocalStorageState(
-    `codecov-selection:${organization.slug}`,
+    `prevent-selection:${organization.slug}`,
     initialLocalStorageState
   );
 
   const [searchParams, setSearchParams] = useSearchParams();
 
-  function _defineParams(): CodecovContextDataParams {
+  function _defineParams(): PreventContextDataParams {
     const currentParams = Object.fromEntries(searchParams.entries());
 
     const localStorageLastVisitedOrgId = localStorageState?.lastVisitedOrgId;
@@ -52,19 +52,19 @@ export default function CodecovQueryParamsProvider({
       (integratedOrgId ? localStorageState?.[integratedOrgId]?.branch : null) ||
       currentParams?.branch ||
       'All Branches';
-    const codecovPeriod =
-      currentParams?.codecovPeriod || localStorageState.codecovPeriod || '24h';
+    const preventPeriod =
+      currentParams?.preventPeriod || localStorageState.preventPeriod || '24h';
 
     return {
       integratedOrgId,
       repository,
       branch,
-      codecovPeriod,
+      preventPeriod,
     };
   }
 
   const changeContextValue = useCallback(
-    (input: Partial<CodecovContextDataParams>) => {
+    (input: Partial<PreventContextDataParams>) => {
       const currentParams = Object.fromEntries(searchParams.entries());
       const integratedOrgId = input.integratedOrgId;
 
@@ -87,7 +87,7 @@ export default function CodecovQueryParamsProvider({
           }
         }
 
-        newState.codecovPeriod = input.codecovPeriod ? input.codecovPeriod : '24h';
+        newState.preventPeriod = input.preventPeriod ? input.preventPeriod : '24h';
 
         return newState;
       });
@@ -102,15 +102,15 @@ export default function CodecovQueryParamsProvider({
     [searchParams, setLocalStorageState, setSearchParams]
   );
 
-  const {integratedOrgId, repository, branch, codecovPeriod} = _defineParams();
+  const {integratedOrgId, repository, branch, preventPeriod} = _defineParams();
 
-  const params: CodecovContextData = {
+  const params: PreventContextData = {
     ...(repository ? {repository} : {}),
     ...(integratedOrgId ? {integratedOrgId} : {}),
     ...(branch ? {branch} : {}),
-    codecovPeriod,
+    preventPeriod,
     changeContextValue,
   };
 
-  return <CodecovContext.Provider value={params}>{children}</CodecovContext.Provider>;
+  return <PreventContext.Provider value={params}>{children}</PreventContext.Provider>;
 }

static/app/components/codecov/branchSelector/useInfiniteRepositoryBranches.tsx renamed to static/app/components/prevent/branchSelector/useInfiniteRepositoryBranches.tsx

@@ -0,0 +1,24 @@
+import {createContext, useContext} from 'react';
+
+export type PreventContextData = {
+  changeContextValue: (value: Partial<PreventContextDataParams>) => void;
+  preventPeriod: string;
+  branch?: string;
+  integratedOrgId?: string;
+  lastVisitedOrgId?: string;
+  repository?: string;
+};
+
+export type PreventContextDataParams = Omit<
+  PreventContextData,
+  'changeContextValue' | 'lastVisitedOrgId'
+>;
+
+export const PreventContext = createContext<PreventContextData | undefined>(undefined);
+
+export function usePreventContext() {
+  const context = useContext(PreventContext);
+  if (context === undefined)
+    throw new Error('usePreventContext was called outside of PreventProvider');
+  return context;
+}

static/app/components/codecov/container/codecovParamsProvider.tsx renamed to static/app/components/prevent/container/preventParamsProvider.tsx

@@ -1,20 +1,20 @@
 import {render, screen} from 'sentry-test/reactTestingLibrary';
 
-import CodecovQueryParamsProvider from 'sentry/components/codecov/container/codecovParamsProvider';
-import {DateSelector} from 'sentry/components/codecov/dateSelector/dateSelector';
+import PreventQueryParamsProvider from 'sentry/components/prevent/container/preventParamsProvider';
+import {DateSelector} from 'sentry/components/prevent/dateSelector/dateSelector';
 
 describe('DateSelector', function () {
   it('renders when given relative period', async function () {
     render(
-      <CodecovQueryParamsProvider>
+      <PreventQueryParamsProvider>
         <DateSelector />
-      </CodecovQueryParamsProvider>,
+      </PreventQueryParamsProvider>,
       {
         initialRouterConfig: {
           location: {
-            pathname: '/codecov/tests',
+            pathname: '/prevent/tests',
             query: {
-              codecovPeriod: '7d',
+              preventPeriod: '7d',
               integratedOrgId: '123',
               repository: 'some-repository',
             },
@@ -27,15 +27,15 @@ describe('DateSelector', function () {
 
   it('renders when given an invalid relative period', async function () {
     render(
-      <CodecovQueryParamsProvider>
+      <PreventQueryParamsProvider>
         <DateSelector />
-      </CodecovQueryParamsProvider>,
+      </PreventQueryParamsProvider>,
       {
         initialRouterConfig: {
           location: {
-            pathname: '/codecov/tests',
+            pathname: '/prevent/tests',
             query: {
-              codecovPeriod: '1y',
+              preventPeriod: '1y',
               integratedOrgId: '123',
               repository: 'some-repository',
             },

static/app/components/prevent/context/preventContext.tsx

@@ -1,40 +1,38 @@
 import {useCallback, useMemo} from 'react';
 import styled from '@emotion/styled';
 
-import {useCodecovContext} from 'sentry/components/codecov/context/codecovContext';
 import type {SelectOption} from 'sentry/components/core/compactSelect';
 import {CompactSelect} from 'sentry/components/core/compactSelect';
 import {Flex} from 'sentry/components/core/layout';
 import DropdownButton from 'sentry/components/dropdownButton';
+import {usePreventContext} from 'sentry/components/prevent/context/preventContext';
 import {getArbitraryRelativePeriod} from 'sentry/components/timeRangeSelector/utils';
 import {IconCalendar} from 'sentry/icons/iconCalendar';
 import {t} from 'sentry/locale';
 
-export const CODECOV_DEFAULT_RELATIVE_PERIODS = {
+const PREVENT_DEFAULT_RELATIVE_PERIODS = {
   '24h': t('Last 24 hours'),
   '7d': t('Last 7 days'),
   '30d': t('Last 30 days'),
 };
 
-export type CodecovPeriodOptions = keyof typeof CODECOV_DEFAULT_RELATIVE_PERIODS;
-
 export function DateSelector() {
-  const {codecovPeriod, changeContextValue} = useCodecovContext();
+  const {preventPeriod, changeContextValue} = usePreventContext();
 
   const handleChange = useCallback(
     (selectedOption: SelectOption<string>) => {
-      changeContextValue({codecovPeriod: selectedOption.value});
+      changeContextValue({preventPeriod: selectedOption.value});
     },
     [changeContextValue]
   );
 
   const options = useMemo((): Array<SelectOption<string>> => {
-    const currentAndDefaultCodecovPeriods = {
-      ...getArbitraryRelativePeriod(codecovPeriod),
-      ...CODECOV_DEFAULT_RELATIVE_PERIODS,
+    const currentAndDefaultPreventPeriods = {
+      ...getArbitraryRelativePeriod(preventPeriod),
+      ...PREVENT_DEFAULT_RELATIVE_PERIODS,
     };
 
-    return Object.entries(currentAndDefaultCodecovPeriods).map(
+    return Object.entries(currentAndDefaultPreventPeriods).map(
       ([key, value]): SelectOption<string> => {
         return {
           value: key,
@@ -43,24 +41,24 @@ export function DateSelector() {
         };
       }
     );
-  }, [codecovPeriod]);
+  }, [preventPeriod]);
 
   return (
     <CompactSelect
       disableSearchFilter
       options={options}
-      value={codecovPeriod ?? ''}
+      value={preventPeriod ?? ''}
       onChange={handleChange}
       menuWidth={'16rem'}
       trigger={(triggerProps, isOpen) => {
-        const defaultLabel = options.some(item => item.value === codecovPeriod)
-          ? codecovPeriod?.toUpperCase()
+        const defaultLabel = options.some(item => item.value === preventPeriod)
+          ? preventPeriod?.toUpperCase()
           : t('Invalid Period');
 
         return (
           <DropdownButton
             isOpen={isOpen}
-            data-test-id="codecov-time-selector"
+            data-test-id="prevent-time-selector"
             {...triggerProps}
           >
             <TriggerLabelWrap>