7288049459

Committed 21 Dec 2023 12:21PM UTC coverage: 37.588% (+2.7%) from 34.84%

Build # 7288049459

Build Type

Pull #45

github

Committed by

web-flow

Commit Message

Merge 56a5db1fb into 94d94c7b3

Pull Request Pull Request #45: codegen output 545b9cde35bc4f4fa9c1ac24a8dcb943

Run Details

1877 of 9030 branches covered (0.0%)

Branch coverage included in aggregate %.

1245 of 1660 new or added lines in 77 files covered. (75.0%)

78 existing lines in 23 files now uncovered.

6088 of 12160 relevant lines covered (50.07%)

75.71 hits per line

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

67.57

/src/managers/fileClassifications.generated.ts

import { serializeClassification } from '../schemas.generated.js';
import { deserializeClassification } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { Classification } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { Authentication } from '../auth.js';
import { NetworkSession } from '../network.js';
import { prepareParams } from '../utils.js';
import { toString } from '../utils.js';
import { ByteStream } from '../utils.js';
import { CancellationToken } from '../utils.js';
import { fetch } from '../fetch.js';
import { FetchOptions } from '../fetch.js';
import { FetchResponse } from '../fetch.js';
import { sdToJson } from '../json.js';
import { SerializedData } from '../json.js';
import { sdIsEmpty } from '../json.js';
import { sdIsBoolean } from '../json.js';
import { sdIsNumber } from '../json.js';
import { sdIsString } from '../json.js';
import { sdIsList } from '../json.js';
import { sdIsMap } from '../json.js';
export class GetClassificationOnFileHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetClassificationOnFileHeaders, 'extraHeaders'>
      | Partial<Pick<GetClassificationOnFileHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export interface AddClassificationToFileRequestBody {
  readonly boxSecurityClassificationKey?: string;
}
export class AddClassificationToFileHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<AddClassificationToFileHeaders, 'extraHeaders'>
      | Partial<Pick<AddClassificationToFileHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type UpdateClassificationOnFileRequestBodyOpField = 'replace';
export type UpdateClassificationOnFileRequestBodyPathField =
  '/Box__Security__Classification__Key';
export interface UpdateClassificationOnFileRequestBody {
  readonly op: UpdateClassificationOnFileRequestBodyOpField;
  readonly path: UpdateClassificationOnFileRequestBodyPathField;
  readonly value: string;
}
export class UpdateClassificationOnFileHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<UpdateClassificationOnFileHeaders, 'extraHeaders'>
      | Partial<Pick<UpdateClassificationOnFileHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteClassificationFromFileHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteClassificationFromFileHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteClassificationFromFileHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class FileClassificationsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          FileClassificationsManager,
          | 'networkSession'
          | 'getClassificationOnFile'
          | 'addClassificationToFile'
          | 'updateClassificationOnFile'
          | 'deleteClassificationFromFile'
        >
      | Partial<Pick<FileClassificationsManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getClassificationOnFile(
    fileId: string,
    headers: GetClassificationOnFileHeaders = new GetClassificationOnFileHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/metadata/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async addClassificationToFile(
    fileId: string,
    requestBody: AddClassificationToFileRequestBody = {} satisfies AddClassificationToFileRequestBody,
    headers: AddClassificationToFileHeaders = new AddClassificationToFileHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/metadata/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeAddClassificationToFileRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async updateClassificationOnFile(
    fileId: string,
    requestBody: readonly UpdateClassificationOnFileRequestBody[],
    headers: UpdateClassificationOnFileHeaders = new UpdateClassificationOnFileHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/metadata/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'PUT',
        headers: headersMap,
        data: requestBody.map(
          serializeUpdateClassificationOnFileRequestBody
        ) as readonly any[],
        contentType: 'application/json-patch+json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async deleteClassificationFromFile(
    fileId: string,
    headers: DeleteClassificationFromFileHeaders = new DeleteClassificationFromFileHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/metadata/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'DELETE',
        headers: headersMap,
        responseFormat: void 0,
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return void 0;
  }
}
export function serializeAddClassificationToFileRequestBody(
  val: AddClassificationToFileRequestBody
): SerializedData {
  return {
    ['Box__Security__Classification__Key']:
      val.boxSecurityClassificationKey == void 0
        ? void 0
        : val.boxSecurityClassificationKey,
  };
}
export function deserializeAddClassificationToFileRequestBody(
  val: any
): AddClassificationToFileRequestBody {
  const boxSecurityClassificationKey: undefined | string =
    val.Box__Security__Classification__Key == void 0
      ? void 0
      : val.Box__Security__Classification__Key;
  return {
    boxSecurityClassificationKey: boxSecurityClassificationKey,
  } satisfies AddClassificationToFileRequestBody;
}
export function serializeUpdateClassificationOnFileRequestBodyOpField(
  val: UpdateClassificationOnFileRequestBodyOpField
): SerializedData {
  return val;
}
export function deserializeUpdateClassificationOnFileRequestBodyOpField(
  val: any
): UpdateClassificationOnFileRequestBodyOpField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateClassificationOnFileRequestBodyOpField"';
  }
  if (val == 'replace') {
    return 'replace';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateClassificationOnFileRequestBodyPathField(
  val: UpdateClassificationOnFileRequestBodyPathField
): SerializedData {
  return val;
}
export function deserializeUpdateClassificationOnFileRequestBodyPathField(
  val: any
): UpdateClassificationOnFileRequestBodyPathField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateClassificationOnFileRequestBodyPathField"';
  }
  if (val == '/Box__Security__Classification__Key') {
    return '/Box__Security__Classification__Key';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateClassificationOnFileRequestBody(
  val: UpdateClassificationOnFileRequestBody
): SerializedData {
  return {
    ['op']: serializeUpdateClassificationOnFileRequestBodyOpField(val.op),
    ['path']: serializeUpdateClassificationOnFileRequestBodyPathField(val.path),
    ['value']: val.value,
  };
}
export function deserializeUpdateClassificationOnFileRequestBody(
  val: any
): UpdateClassificationOnFileRequestBody {
  const op: UpdateClassificationOnFileRequestBodyOpField =
    deserializeUpdateClassificationOnFileRequestBodyOpField(val.op);
  const path: UpdateClassificationOnFileRequestBodyPathField =
    deserializeUpdateClassificationOnFileRequestBodyPathField(val.path);
  const value: string = val.value;
  return {
    op: op,
    path: path,
    value: value,
  } satisfies UpdateClassificationOnFileRequestBody;
}

1	import { serializeClassification } from '../schemas.generated.js';
2	import { deserializeClassification } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { Classification } from '../schemas.generated.js';
6	import { ClientError } from '../schemas.generated.js';
7	import { Authentication } from '../auth.js';
8	import { NetworkSession } from '../network.js';	165✔
9	import { prepareParams } from '../utils.js';	165✔
10	import { toString } from '../utils.js';	165✔
11	import { ByteStream } from '../utils.js';
12	import { CancellationToken } from '../utils.js';
13	import { fetch } from '../fetch.js';	165✔
14	import { FetchOptions } from '../fetch.js';
15	import { FetchResponse } from '../fetch.js';
16	import { sdToJson } from '../json.js';
17	import { SerializedData } from '../json.js';
18	import { sdIsEmpty } from '../json.js';
19	import { sdIsBoolean } from '../json.js';
20	import { sdIsNumber } from '../json.js';
21	import { sdIsString } from '../json.js';	165✔
22	import { sdIsList } from '../json.js';
23	import { sdIsMap } from '../json.js';
24	export class GetClassificationOnFileHeaders {	165✔
25	readonly extraHeaders?: {	9✔
26	readonly [key: string]: undefined \| string;
27	} = {};
28	constructor(
29	fields:
30	\| Omit<GetClassificationOnFileHeaders, 'extraHeaders'>
31	\| Partial<Pick<GetClassificationOnFileHeaders, 'extraHeaders'>>
32	) {
33	Object.assign(this, fields);	9✔
34	}
35	}
36	export interface AddClassificationToFileRequestBody {
37	readonly boxSecurityClassificationKey?: string;
38	}
39	export class AddClassificationToFileHeaders {	165✔
40	readonly extraHeaders?: {	3✔
41	readonly [key: string]: undefined \| string;
42	} = {};
43	constructor(
44	fields:
45	\| Omit<AddClassificationToFileHeaders, 'extraHeaders'>
46	\| Partial<Pick<AddClassificationToFileHeaders, 'extraHeaders'>>
47	) {
48	Object.assign(this, fields);	3✔
49	}
50	}
51	export type UpdateClassificationOnFileRequestBodyOpField = 'replace';
52	export type UpdateClassificationOnFileRequestBodyPathField =
53	'/Box__Security__Classification__Key';
54	export interface UpdateClassificationOnFileRequestBody {
55	readonly op: UpdateClassificationOnFileRequestBodyOpField;
56	readonly path: UpdateClassificationOnFileRequestBodyPathField;
57	readonly value: string;
58	}
59	export class UpdateClassificationOnFileHeaders {	165✔
60	readonly extraHeaders?: {	3✔
61	readonly [key: string]: undefined \| string;
62	} = {};
63	constructor(
64	fields:
65	\| Omit<UpdateClassificationOnFileHeaders, 'extraHeaders'>
66	\| Partial<Pick<UpdateClassificationOnFileHeaders, 'extraHeaders'>>
67	) {
68	Object.assign(this, fields);	3✔
69	}
70	}
71	export class DeleteClassificationFromFileHeaders {	165✔
72	readonly extraHeaders?: {	3✔
73	readonly [key: string]: undefined \| string;
74	} = {};
75	constructor(
76	fields:
77	\| Omit<DeleteClassificationFromFileHeaders, 'extraHeaders'>
78	\| Partial<Pick<DeleteClassificationFromFileHeaders, 'extraHeaders'>>
79	) {
80	Object.assign(this, fields);	3✔
81	}
82	}
83	export class FileClassificationsManager {	165✔
84	readonly auth?: Authentication;
85	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
86	constructor(
87	fields:
88	\| Omit<
89	FileClassificationsManager,
90	\| 'networkSession'
91	\| 'getClassificationOnFile'
92	\| 'addClassificationToFile'
93	\| 'updateClassificationOnFile'
94	\| 'deleteClassificationFromFile'
95	>
96	\| Partial<Pick<FileClassificationsManager, 'networkSession'>>
97	) {
98	Object.assign(this, fields);	285✔
99	}
100	async getClassificationOnFile(
101	fileId: string,
102	headers: GetClassificationOnFileHeaders = new GetClassificationOnFileHeaders(	9✔
103	{}
104	),
105	cancellationToken?: CancellationToken
106	): Promise<Classification> {
107	const headersMap: {
108	readonly [key: string]: string;
109	} = prepareParams({ ...{}, ...headers.extraHeaders });	9✔
110	const response: FetchResponse = (await fetch(	9✔
111	''.concat(
112	this.networkSession.baseUrls.baseUrl,
113	'/files/',
114	toString(fileId) as string,
115	'/metadata/enterprise/securityClassification-6VMVochwUWo'
116	) as string,
117	{
118	method: 'GET',
119	headers: headersMap,
120	responseFormat: 'json',
121	auth: this.auth,
122	networkSession: this.networkSession,
123	cancellationToken: cancellationToken,
124	} satisfies FetchOptions
125	)) as FetchResponse;
126	return deserializeClassification(response.data);	3✔
127	}
128	async addClassificationToFile(
129	fileId: string,
130	requestBody: AddClassificationToFileRequestBody = {} satisfies AddClassificationToFileRequestBody,	×
131	headers: AddClassificationToFileHeaders = new AddClassificationToFileHeaders(	3✔
132	{}
133	),
134	cancellationToken?: CancellationToken
135	): Promise<Classification> {
136	const headersMap: {
137	readonly [key: string]: string;
138	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
139	const response: FetchResponse = (await fetch(	3✔
140	''.concat(
141	this.networkSession.baseUrls.baseUrl,
142	'/files/',
143	toString(fileId) as string,
144	'/metadata/enterprise/securityClassification-6VMVochwUWo'
145	) as string,
146	{
147	method: 'POST',
148	headers: headersMap,
149	data: serializeAddClassificationToFileRequestBody(requestBody),
150	contentType: 'application/json',
151	responseFormat: 'json',
152	auth: this.auth,
153	networkSession: this.networkSession,
154	cancellationToken: cancellationToken,
155	} satisfies FetchOptions
156	)) as FetchResponse;
157	return deserializeClassification(response.data);	3✔
158	}
159	async updateClassificationOnFile(
160	fileId: string,
161	requestBody: readonly UpdateClassificationOnFileRequestBody[],
162	headers: UpdateClassificationOnFileHeaders = new UpdateClassificationOnFileHeaders(	3✔
163	{}
164	),
165	cancellationToken?: CancellationToken
166	): Promise<Classification> {
167	const headersMap: {
168	readonly [key: string]: string;
169	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
170	const response: FetchResponse = (await fetch(	3✔
171	''.concat(
172	this.networkSession.baseUrls.baseUrl,
173	'/files/',
174	toString(fileId) as string,
175	'/metadata/enterprise/securityClassification-6VMVochwUWo'
176	) as string,
177	{
178	method: 'PUT',
179	headers: headersMap,
180	data: requestBody.map(
181	serializeUpdateClassificationOnFileRequestBody
182	) as readonly any[],
183	contentType: 'application/json-patch+json',
184	responseFormat: 'json',
185	auth: this.auth,
186	networkSession: this.networkSession,
187	cancellationToken: cancellationToken,
188	} satisfies FetchOptions
189	)) as FetchResponse;
190	return deserializeClassification(response.data);	3✔
191	}
192	async deleteClassificationFromFile(
193	fileId: string,
194	headers: DeleteClassificationFromFileHeaders = new DeleteClassificationFromFileHeaders(	3✔
195	{}
196	),
197	cancellationToken?: CancellationToken
198	): Promise<undefined> {
199	const headersMap: {
200	readonly [key: string]: string;
201	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
202	const response: FetchResponse = (await fetch(	3✔
203	''.concat(
204	this.networkSession.baseUrls.baseUrl,
205	'/files/',
206	toString(fileId) as string,
207	'/metadata/enterprise/securityClassification-6VMVochwUWo'
208	) as string,
209	{
210	method: 'DELETE',
211	headers: headersMap,
212	responseFormat: void 0,
213	auth: this.auth,
214	networkSession: this.networkSession,
215	cancellationToken: cancellationToken,
216	} satisfies FetchOptions
217	)) as FetchResponse;
218	return void 0;	3✔
219	}
220	}
221	export function serializeAddClassificationToFileRequestBody(	165✔
222	val: AddClassificationToFileRequestBody
223	): SerializedData {
224	return {	3✔
225	['Box__Security__Classification__Key']:
226	val.boxSecurityClassificationKey == void 0	3!
227	? void 0
228	: val.boxSecurityClassificationKey,
229	};
230	}
231	export function deserializeAddClassificationToFileRequestBody(	165✔
232	val: any
233	): AddClassificationToFileRequestBody {
234	const boxSecurityClassificationKey: undefined \| string =
235	val.Box__Security__Classification__Key == void 0	×
236	? void 0
237	: val.Box__Security__Classification__Key;
238	return {	×
239	boxSecurityClassificationKey: boxSecurityClassificationKey,
240	} satisfies AddClassificationToFileRequestBody;
241	}
242	export function serializeUpdateClassificationOnFileRequestBodyOpField(	165✔
243	val: UpdateClassificationOnFileRequestBodyOpField
244	): SerializedData {
245	return val;	3✔
246	}
247	export function deserializeUpdateClassificationOnFileRequestBodyOpField(	165✔
248	val: any
249	): UpdateClassificationOnFileRequestBodyOpField {
250	if (!sdIsString(val)) {	×
NEW 251	throw 'Expecting a string for "UpdateClassificationOnFileRequestBodyOpField"';	×
252	}
253	if (val == 'replace') {	×
254	return 'replace';	×
255	}
256	throw ''.concat('Invalid value: ', val) as string;	×
257	}
258	export function serializeUpdateClassificationOnFileRequestBodyPathField(	165✔
259	val: UpdateClassificationOnFileRequestBodyPathField
260	): SerializedData {
261	return val;	3✔
262	}
263	export function deserializeUpdateClassificationOnFileRequestBodyPathField(	165✔
264	val: any
265	): UpdateClassificationOnFileRequestBodyPathField {
266	if (!sdIsString(val)) {	×
NEW 267	throw 'Expecting a string for "UpdateClassificationOnFileRequestBodyPathField"';	×
268	}
NEW 269	if (val == '/Box__Security__Classification__Key') {	×
NEW 270	return '/Box__Security__Classification__Key';	×
271	}
272	throw ''.concat('Invalid value: ', val) as string;	×
273	}
274	export function serializeUpdateClassificationOnFileRequestBody(	165✔
275	val: UpdateClassificationOnFileRequestBody
276	): SerializedData {
277	return {	3✔
278	['op']: serializeUpdateClassificationOnFileRequestBodyOpField(val.op),
279	['path']: serializeUpdateClassificationOnFileRequestBodyPathField(val.path),
280	['value']: val.value,
281	};
282	}
283	export function deserializeUpdateClassificationOnFileRequestBody(	165✔
284	val: any
285	): UpdateClassificationOnFileRequestBody {
286	const op: UpdateClassificationOnFileRequestBodyOpField =
NEW 287	deserializeUpdateClassificationOnFileRequestBodyOpField(val.op);	×
288	const path: UpdateClassificationOnFileRequestBodyPathField =
NEW 289	deserializeUpdateClassificationOnFileRequestBodyPathField(val.path);	×
NEW 290	const value: string = val.value;	×
UNCOV 291	return {	×
292	op: op,
293	path: path,
294	value: value,
295	} satisfies UpdateClassificationOnFileRequestBody;
296	}

box / box-typescript-sdk-gen / 7288049459

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