16145759281

Committed 08 Jul 2025 02:14PM UTC coverage: 42.108% (+0.06%) from 42.048%

Build # 16145759281

Build Type

Pull #659

github

Committed by

web-flow

Commit Message

Merge 048f2ffab into cb0c35df4

Pull Request Pull Request #659: test: Improve names in transfer integration test (box/box-codegen#759)

Run Details

4375 of 18050 branches covered (24.24%)

Branch coverage included in aggregate %.

16066 of 30494 relevant lines covered (52.69%)

145.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.0

/src/networking/retries.generated.ts

import { FetchOptions } from './fetchOptions.generated.js';
import { FetchResponse } from './fetchResponse.generated.js';
import { random } from '../internal/utils.js';
export interface RetryStrategy {
  /**
   * @param {FetchOptions} fetchOptions
   * @param {FetchResponse} fetchResponse
   * @param {number} attemptNumber
   * @returns {Promise<boolean>}
   */
  shouldRetry(
    fetchOptions: FetchOptions,
    fetchResponse: FetchResponse,
    attemptNumber: number,
  ): Promise<boolean>;
  /**
   * @param {FetchOptions} fetchOptions
   * @param {FetchResponse} fetchResponse
   * @param {number} attemptNumber
   * @returns {number}
   */
  retryAfter(
    fetchOptions: FetchOptions,
    fetchResponse: FetchResponse,
    attemptNumber: number,
  ): number;
}
export class BoxRetryStrategy implements RetryStrategy {
  readonly maxAttempts: number = 5;
  readonly retryRandomizationFactor: number = 0.5;
  readonly retryBaseInterval: number = 1;
  constructor(
    fields: Omit<
      BoxRetryStrategy,
      | 'maxAttempts'
      | 'retryRandomizationFactor'
      | 'retryBaseInterval'
      | 'shouldRetry'
      | 'retryAfter'
    > &
      Partial<
        Pick<
          BoxRetryStrategy,
          'maxAttempts' | 'retryRandomizationFactor' | 'retryBaseInterval'
        >
      >,
  ) {
    if (fields.maxAttempts !== undefined) {
      this.maxAttempts = fields.maxAttempts;
    }
    if (fields.retryRandomizationFactor !== undefined) {
      this.retryRandomizationFactor = fields.retryRandomizationFactor;
    }
    if (fields.retryBaseInterval !== undefined) {
      this.retryBaseInterval = fields.retryBaseInterval;
    }
  }
  /**
   * @param {FetchOptions} fetchOptions
   * @param {FetchResponse} fetchResponse
   * @param {number} attemptNumber
   * @returns {Promise<boolean>}
   */
  async shouldRetry(
    fetchOptions: FetchOptions,
    fetchResponse: FetchResponse,
    attemptNumber: number,
  ): Promise<boolean> {
    const isSuccessful: boolean =
      fetchResponse.status >= 200 && fetchResponse.status < 400;
    const retryAfterHeader: string = fetchResponse.headers['Retry-After'];
    const isAcceptedWithRetryAfter: boolean =
      fetchResponse.status == 202 && !(retryAfterHeader == void 0);
    if (attemptNumber >= this.maxAttempts) {
      return false;
    }
    if (isAcceptedWithRetryAfter) {
      return true;
    }
    if (fetchResponse.status >= 500) {
      return true;
    }
    if (fetchResponse.status == 429) {
      return true;
    }
    if (fetchResponse.status == 401 && !(fetchOptions.auth == void 0)) {
      await fetchOptions.auth.refreshToken(fetchOptions.networkSession);
      return true;
    }
    if (isSuccessful) {
      return false;
    }
    return false;
  }
  /**
   * @param {FetchOptions} fetchOptions
   * @param {FetchResponse} fetchResponse
   * @param {number} attemptNumber
   * @returns {number}
   */
  retryAfter(
    fetchOptions: FetchOptions,
    fetchResponse: FetchResponse,
    attemptNumber: number,
  ): number {
    const retryAfterHeader: string = fetchResponse.headers['Retry-After'];
    if (!(retryAfterHeader == void 0)) {
      return parseFloat(retryAfterHeader) as number;
    }
    const randomization: number = random(
      1 - this.retryRandomizationFactor,
      1 + this.retryRandomizationFactor,
    );
    const exponential: number = 2 ** attemptNumber;
    return exponential * this.retryBaseInterval * randomization;
  }
}

1	import { FetchOptions } from './fetchOptions.generated.js';
2	import { FetchResponse } from './fetchResponse.generated.js';
3	import { random } from '../internal/utils.js';	234✔
4	export interface RetryStrategy {
5	/**
6	* @param {FetchOptions} fetchOptions
7	* @param {FetchResponse} fetchResponse
8	* @param {number} attemptNumber
9	* @returns {Promise<boolean>}
10	*/
11	shouldRetry(
12	fetchOptions: FetchOptions,
13	fetchResponse: FetchResponse,
14	attemptNumber: number,
15	): Promise<boolean>;
16	/**
17	* @param {FetchOptions} fetchOptions
18	* @param {FetchResponse} fetchResponse
19	* @param {number} attemptNumber
20	* @returns {number}
21	*/
22	retryAfter(
23	fetchOptions: FetchOptions,
24	fetchResponse: FetchResponse,
25	attemptNumber: number,
26	): number;
27	}
28	export class BoxRetryStrategy implements RetryStrategy {	234✔
29	readonly maxAttempts: number = 5;	40,048✔
30	readonly retryRandomizationFactor: number = 0.5;	40,048✔
31	readonly retryBaseInterval: number = 1;	40,048✔
32	constructor(
33	fields: Omit<
34	BoxRetryStrategy,
35	\| 'maxAttempts'
36	\| 'retryRandomizationFactor'
37	\| 'retryBaseInterval'
38	\| 'shouldRetry'
39	\| 'retryAfter'
40	> &
41	Partial<
42	Pick<
43	BoxRetryStrategy,
44	'maxAttempts' \| 'retryRandomizationFactor' \| 'retryBaseInterval'
45	>
46	>,
47	) {
48	if (fields.maxAttempts !== undefined) {	40,048!
49	this.maxAttempts = fields.maxAttempts;	×
50	}
51	if (fields.retryRandomizationFactor !== undefined) {	40,048!
52	this.retryRandomizationFactor = fields.retryRandomizationFactor;	×
53	}
54	if (fields.retryBaseInterval !== undefined) {	40,048!
55	this.retryBaseInterval = fields.retryBaseInterval;	×
56	}
57	}
58	/**
59	* @param {FetchOptions} fetchOptions
60	* @param {FetchResponse} fetchResponse
61	* @param {number} attemptNumber
62	* @returns {Promise<boolean>}
63	*/
64	async shouldRetry(
65	fetchOptions: FetchOptions,
66	fetchResponse: FetchResponse,
67	attemptNumber: number,
68	): Promise<boolean> {
69	const isSuccessful: boolean =
70	fetchResponse.status >= 200 && fetchResponse.status < 400;	2,677✔
71	const retryAfterHeader: string = fetchResponse.headers['Retry-After'];	2,677✔
72	const isAcceptedWithRetryAfter: boolean =
73	fetchResponse.status == 202 && !(retryAfterHeader == void 0);	2,677✔
74	if (attemptNumber >= this.maxAttempts) {	2,677!
75	return false;	×
76	}
77	if (isAcceptedWithRetryAfter) {	2,677!
78	return true;	×
79	}
80	if (fetchResponse.status >= 500) {	2,677!
81	return true;	×
82	}
83	if (fetchResponse.status == 429) {	2,677!
84	return true;	×
85	}
86	if (fetchResponse.status == 401 && !(fetchOptions.auth == void 0)) {	2,677✔
87	await fetchOptions.auth.refreshToken(fetchOptions.networkSession);	3✔
88	return true;	×
89	}
90	if (isSuccessful) {	2,674✔
91	return false;	2,506✔
92	}
93	return false;	168✔
94	}
95	/**
96	* @param {FetchOptions} fetchOptions
97	* @param {FetchResponse} fetchResponse
98	* @param {number} attemptNumber
99	* @returns {number}
100	*/
101	retryAfter(
102	fetchOptions: FetchOptions,
103	fetchResponse: FetchResponse,
104	attemptNumber: number,
105	): number {
106	const retryAfterHeader: string = fetchResponse.headers['Retry-After'];	×
107	if (!(retryAfterHeader == void 0)) {	×
108	return parseFloat(retryAfterHeader) as number;	×
109	}
110	const randomization: number = random(	×
111	1 - this.retryRandomizationFactor,
112	1 + this.retryRandomizationFactor,
113	);
114	const exponential: number = 2 ** attemptNumber;	×
115	return exponential * this.retryBaseInterval * randomization;	×
116	}
117	}

box / box-typescript-sdk-gen / 16145759281

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous