#5076

Committed 07 Oct 2025 12:35PM UTC coverage: 37.132% (+0.007%) from 37.125%

Build # #5076

Build Type

push

github

Committed by

web-flow

Commit Message

test: Change `Event.additionalDetails` field assertion in events test (box/box-codegen#858) (#1491)

Run Details

18454 of 49699 relevant lines covered (37.13%)

0.37 hits per line

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

91.59

/src/main/java/com/box/sdkgen/managers/aistudio/AiStudioManager.java

package com.box.sdkgen.managers.aistudio;

import static com.box.sdkgen.internal.utils.UtilsManager.convertToString;
import static com.box.sdkgen.internal.utils.UtilsManager.entryOf;
import static com.box.sdkgen.internal.utils.UtilsManager.mapOf;
import static com.box.sdkgen.internal.utils.UtilsManager.mergeMaps;
import static com.box.sdkgen.internal.utils.UtilsManager.prepareParams;

import com.box.sdkgen.networking.auth.Authentication;
import com.box.sdkgen.networking.fetchoptions.FetchOptions;
import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
import com.box.sdkgen.networking.fetchresponse.FetchResponse;
import com.box.sdkgen.networking.network.NetworkSession;
import com.box.sdkgen.schemas.aimultipleagentresponse.AiMultipleAgentResponse;
import com.box.sdkgen.schemas.aisingleagentresponsefull.AiSingleAgentResponseFull;
import com.box.sdkgen.schemas.createaiagent.CreateAiAgent;
import com.box.sdkgen.serialization.json.JsonManager;
import java.util.Map;

public class AiStudioManager {

  public Authentication auth;

  public NetworkSession networkSession;

  public AiStudioManager() {
    this.networkSession = new NetworkSession();
  }

  protected AiStudioManager(Builder builder) {
    this.auth = builder.auth;
    this.networkSession = builder.networkSession;
  }

  /** Lists AI agents based on the provided parameters. */
  public AiMultipleAgentResponse getAiAgents() {
    return getAiAgents(new GetAiAgentsQueryParams(), new GetAiAgentsHeaders());
  }

  /**
   * Lists AI agents based on the provided parameters.
   *
   * @param queryParams Query parameters of getAiAgents method
   */
  public AiMultipleAgentResponse getAiAgents(GetAiAgentsQueryParams queryParams) {
    return getAiAgents(queryParams, new GetAiAgentsHeaders());
  }

  /**
   * Lists AI agents based on the provided parameters.
   *
   * @param headers Headers of getAiAgents method
   */
  public AiMultipleAgentResponse getAiAgents(GetAiAgentsHeaders headers) {
    return getAiAgents(new GetAiAgentsQueryParams(), headers);
  }

  /**
   * Lists AI agents based on the provided parameters.
   *
   * @param queryParams Query parameters of getAiAgents method
   * @param headers Headers of getAiAgents method
   */
  public AiMultipleAgentResponse getAiAgents(
      GetAiAgentsQueryParams queryParams, GetAiAgentsHeaders headers) {
    Map<String, String> queryParamsMap =
        prepareParams(
            mapOf(
                entryOf("mode", convertToString(queryParams.getMode())),
                entryOf("fields", convertToString(queryParams.getFields())),
                entryOf("agent_state", convertToString(queryParams.getAgentState())),
                entryOf("include_box_default", convertToString(queryParams.getIncludeBoxDefault())),
                entryOf("marker", convertToString(queryParams.getMarker())),
                entryOf("limit", convertToString(queryParams.getLimit()))));
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.Builder(
                        String.join(
                            "", this.networkSession.getBaseUrls().getBaseUrl(), "/2.0/ai_agents"),
                        "GET")
                    .params(queryParamsMap)
                    .headers(headersMap)
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), AiMultipleAgentResponse.class);
  }

  /**
   * Creates an AI agent. At least one of the following capabilities must be provided: `ask`,
   * `text_gen`, `extract`.
   *
   * @param requestBody Request body of createAiAgent method
   */
  public AiSingleAgentResponseFull createAiAgent(CreateAiAgent requestBody) {
    return createAiAgent(requestBody, new CreateAiAgentHeaders());
  }

  /**
   * Creates an AI agent. At least one of the following capabilities must be provided: `ask`,
   * `text_gen`, `extract`.
   *
   * @param requestBody Request body of createAiAgent method
   * @param headers Headers of createAiAgent method
   */
  public AiSingleAgentResponseFull createAiAgent(
      CreateAiAgent requestBody, CreateAiAgentHeaders headers) {
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.Builder(
                        String.join(
                            "", this.networkSession.getBaseUrls().getBaseUrl(), "/2.0/ai_agents"),
                        "POST")
                    .headers(headersMap)
                    .data(JsonManager.serialize(requestBody))
                    .contentType("application/json")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);
  }

  /**
   * Updates an AI agent.
   *
   * @param agentId The ID of the agent to update. Example: "1234"
   * @param requestBody Request body of updateAiAgentById method
   */
  public AiSingleAgentResponseFull updateAiAgentById(String agentId, CreateAiAgent requestBody) {
    return updateAiAgentById(agentId, requestBody, new UpdateAiAgentByIdHeaders());
  }

  /**
   * Updates an AI agent.
   *
   * @param agentId The ID of the agent to update. Example: "1234"
   * @param requestBody Request body of updateAiAgentById method
   * @param headers Headers of updateAiAgentById method
   */
  public AiSingleAgentResponseFull updateAiAgentById(
      String agentId, CreateAiAgent requestBody, UpdateAiAgentByIdHeaders headers) {
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.Builder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getBaseUrl(),
                            "/2.0/ai_agents/",
                            convertToString(agentId)),
                        "PUT")
                    .headers(headersMap)
                    .data(JsonManager.serialize(requestBody))
                    .contentType("application/json")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);
  }

  /**
   * Gets an AI Agent using the `agent_id` parameter.
   *
   * @param agentId The agent id to get. Example: "1234"
   */
  public AiSingleAgentResponseFull getAiAgentById(String agentId) {
    return getAiAgentById(agentId, new GetAiAgentByIdQueryParams(), new GetAiAgentByIdHeaders());
  }

  /**
   * Gets an AI Agent using the `agent_id` parameter.
   *
   * @param agentId The agent id to get. Example: "1234"
   * @param queryParams Query parameters of getAiAgentById method
   */
  public AiSingleAgentResponseFull getAiAgentById(
      String agentId, GetAiAgentByIdQueryParams queryParams) {
    return getAiAgentById(agentId, queryParams, new GetAiAgentByIdHeaders());
  }

  /**
   * Gets an AI Agent using the `agent_id` parameter.
   *
   * @param agentId The agent id to get. Example: "1234"
   * @param headers Headers of getAiAgentById method
   */
  public AiSingleAgentResponseFull getAiAgentById(String agentId, GetAiAgentByIdHeaders headers) {
    return getAiAgentById(agentId, new GetAiAgentByIdQueryParams(), headers);
  }

  /**
   * Gets an AI Agent using the `agent_id` parameter.
   *
   * @param agentId The agent id to get. Example: "1234"
   * @param queryParams Query parameters of getAiAgentById method
   * @param headers Headers of getAiAgentById method
   */
  public AiSingleAgentResponseFull getAiAgentById(
      String agentId, GetAiAgentByIdQueryParams queryParams, GetAiAgentByIdHeaders headers) {
    Map<String, String> queryParamsMap =
        prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.Builder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getBaseUrl(),
                            "/2.0/ai_agents/",
                            convertToString(agentId)),
                        "GET")
                    .params(queryParamsMap)
                    .headers(headersMap)
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);
  }

  /**
   * Deletes an AI agent using the provided parameters.
   *
   * @param agentId The ID of the agent to delete. Example: "1234"
   */
  public void deleteAiAgentById(String agentId) {
    deleteAiAgentById(agentId, new DeleteAiAgentByIdHeaders());
  }

  /**
   * Deletes an AI agent using the provided parameters.
   *
   * @param agentId The ID of the agent to delete. Example: "1234"
   * @param headers Headers of deleteAiAgentById method
   */
  public void deleteAiAgentById(String agentId, DeleteAiAgentByIdHeaders headers) {
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.Builder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getBaseUrl(),
                            "/2.0/ai_agents/",
                            convertToString(agentId)),
                        "DELETE")
                    .headers(headersMap)
                    .responseFormat(ResponseFormat.NO_CONTENT)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
  }

  public Authentication getAuth() {
    return auth;
  }

  public NetworkSession getNetworkSession() {
    return networkSession;
  }

  public static class Builder {

    protected Authentication auth;

    protected NetworkSession networkSession;

    public Builder() {
      this.networkSession = new NetworkSession();
    }

    public Builder auth(Authentication auth) {
      this.auth = auth;
      return this;
    }

    public Builder networkSession(NetworkSession networkSession) {
      this.networkSession = networkSession;
      return this;
    }

    public AiStudioManager build() {
      return new AiStudioManager(this);
    }
  }
}

1	package com.box.sdkgen.managers.aistudio;
2
3	import static com.box.sdkgen.internal.utils.UtilsManager.convertToString;
4	import static com.box.sdkgen.internal.utils.UtilsManager.entryOf;
5	import static com.box.sdkgen.internal.utils.UtilsManager.mapOf;
6	import static com.box.sdkgen.internal.utils.UtilsManager.mergeMaps;
7	import static com.box.sdkgen.internal.utils.UtilsManager.prepareParams;
8
9	import com.box.sdkgen.networking.auth.Authentication;
10	import com.box.sdkgen.networking.fetchoptions.FetchOptions;
11	import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
12	import com.box.sdkgen.networking.fetchresponse.FetchResponse;
13	import com.box.sdkgen.networking.network.NetworkSession;
14	import com.box.sdkgen.schemas.aimultipleagentresponse.AiMultipleAgentResponse;
15	import com.box.sdkgen.schemas.aisingleagentresponsefull.AiSingleAgentResponseFull;
16	import com.box.sdkgen.schemas.createaiagent.CreateAiAgent;
17	import com.box.sdkgen.serialization.json.JsonManager;
18	import java.util.Map;
19
20	public class AiStudioManager {
21
22	public Authentication auth;
23
24	public NetworkSession networkSession;
25
26	public AiStudioManager() {	×
27	this.networkSession = new NetworkSession();	×
28	}	×
29
30	protected AiStudioManager(Builder builder) {	1✔
31	this.auth = builder.auth;	1✔
32	this.networkSession = builder.networkSession;	1✔
33	}	1✔
34
35	/** Lists AI agents based on the provided parameters. */
36	public AiMultipleAgentResponse getAiAgents() {
37	return getAiAgents(new GetAiAgentsQueryParams(), new GetAiAgentsHeaders());	1✔
38	}
39
40	/**
41	* Lists AI agents based on the provided parameters.
42	*
43	* @param queryParams Query parameters of getAiAgents method
44	*/
45	public AiMultipleAgentResponse getAiAgents(GetAiAgentsQueryParams queryParams) {
46	return getAiAgents(queryParams, new GetAiAgentsHeaders());	×
47	}
48
49	/**
50	* Lists AI agents based on the provided parameters.
51	*
52	* @param headers Headers of getAiAgents method
53	*/
54	public AiMultipleAgentResponse getAiAgents(GetAiAgentsHeaders headers) {
55	return getAiAgents(new GetAiAgentsQueryParams(), headers);	×
56	}
57
58	/**
59	* Lists AI agents based on the provided parameters.
60	*
61	* @param queryParams Query parameters of getAiAgents method
62	* @param headers Headers of getAiAgents method
63	*/
64	public AiMultipleAgentResponse getAiAgents(
65	GetAiAgentsQueryParams queryParams, GetAiAgentsHeaders headers) {
66	Map<String, String> queryParamsMap =	1✔
67	prepareParams(	1✔
68	mapOf(	1✔
69	entryOf("mode", convertToString(queryParams.getMode())),	1✔
70	entryOf("fields", convertToString(queryParams.getFields())),	1✔
71	entryOf("agent_state", convertToString(queryParams.getAgentState())),	1✔
72	entryOf("include_box_default", convertToString(queryParams.getIncludeBoxDefault())),	1✔
73	entryOf("marker", convertToString(queryParams.getMarker())),	1✔
74	entryOf("limit", convertToString(queryParams.getLimit()))));	1✔
75	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
76	FetchResponse response =	1✔
77	this.networkSession
78	.getNetworkClient()	1✔
79	.fetch(	1✔
80	new FetchOptions.Builder(
81	String.join(	1✔
82	"", this.networkSession.getBaseUrls().getBaseUrl(), "/2.0/ai_agents"),	1✔
83	"GET")
84	.params(queryParamsMap)	1✔
85	.headers(headersMap)	1✔
86	.responseFormat(ResponseFormat.JSON)	1✔
87	.auth(this.auth)	1✔
88	.networkSession(this.networkSession)	1✔
89	.build());	1✔
90	return JsonManager.deserialize(response.getData(), AiMultipleAgentResponse.class);	1✔
91	}
92
93	/**
94	* Creates an AI agent. At least one of the following capabilities must be provided: `ask`,
95	* `text_gen`, `extract`.
96	*
97	* @param requestBody Request body of createAiAgent method
98	*/
99	public AiSingleAgentResponseFull createAiAgent(CreateAiAgent requestBody) {
100	return createAiAgent(requestBody, new CreateAiAgentHeaders());	1✔
101	}
102
103	/**
104	* Creates an AI agent. At least one of the following capabilities must be provided: `ask`,
105	* `text_gen`, `extract`.
106	*
107	* @param requestBody Request body of createAiAgent method
108	* @param headers Headers of createAiAgent method
109	*/
110	public AiSingleAgentResponseFull createAiAgent(
111	CreateAiAgent requestBody, CreateAiAgentHeaders headers) {
112	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
113	FetchResponse response =	1✔
114	this.networkSession
115	.getNetworkClient()	1✔
116	.fetch(	1✔
117	new FetchOptions.Builder(
118	String.join(	1✔
119	"", this.networkSession.getBaseUrls().getBaseUrl(), "/2.0/ai_agents"),	1✔
120	"POST")
121	.headers(headersMap)	1✔
122	.data(JsonManager.serialize(requestBody))	1✔
123	.contentType("application/json")	1✔
124	.responseFormat(ResponseFormat.JSON)	1✔
125	.auth(this.auth)	1✔
126	.networkSession(this.networkSession)	1✔
127	.build());	1✔
128	return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);	1✔
129	}
130
131	/**
132	* Updates an AI agent.
133	*
134	* @param agentId The ID of the agent to update. Example: "1234"
135	* @param requestBody Request body of updateAiAgentById method
136	*/
137	public AiSingleAgentResponseFull updateAiAgentById(String agentId, CreateAiAgent requestBody) {
138	return updateAiAgentById(agentId, requestBody, new UpdateAiAgentByIdHeaders());	1✔
139	}
140
141	/**
142	* Updates an AI agent.
143	*
144	* @param agentId The ID of the agent to update. Example: "1234"
145	* @param requestBody Request body of updateAiAgentById method
146	* @param headers Headers of updateAiAgentById method
147	*/
148	public AiSingleAgentResponseFull updateAiAgentById(
149	String agentId, CreateAiAgent requestBody, UpdateAiAgentByIdHeaders headers) {
150	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
151	FetchResponse response =	1✔
152	this.networkSession
153	.getNetworkClient()	1✔
154	.fetch(	1✔
155	new FetchOptions.Builder(
156	String.join(	1✔
157	"",
158	this.networkSession.getBaseUrls().getBaseUrl(),	1✔
159	"/2.0/ai_agents/",
160	convertToString(agentId)),	1✔
161	"PUT")
162	.headers(headersMap)	1✔
163	.data(JsonManager.serialize(requestBody))	1✔
164	.contentType("application/json")	1✔
165	.responseFormat(ResponseFormat.JSON)	1✔
166	.auth(this.auth)	1✔
167	.networkSession(this.networkSession)	1✔
168	.build());	1✔
169	return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);	1✔
170	}
171
172	/**
173	* Gets an AI Agent using the `agent_id` parameter.
174	*
175	* @param agentId The agent id to get. Example: "1234"
176	*/
177	public AiSingleAgentResponseFull getAiAgentById(String agentId) {
178	return getAiAgentById(agentId, new GetAiAgentByIdQueryParams(), new GetAiAgentByIdHeaders());	×
179	}
180
181	/**
182	* Gets an AI Agent using the `agent_id` parameter.
183	*
184	* @param agentId The agent id to get. Example: "1234"
185	* @param queryParams Query parameters of getAiAgentById method
186	*/
187	public AiSingleAgentResponseFull getAiAgentById(
188	String agentId, GetAiAgentByIdQueryParams queryParams) {
189	return getAiAgentById(agentId, queryParams, new GetAiAgentByIdHeaders());	1✔
190	}
191
192	/**
193	* Gets an AI Agent using the `agent_id` parameter.
194	*
195	* @param agentId The agent id to get. Example: "1234"
196	* @param headers Headers of getAiAgentById method
197	*/
198	public AiSingleAgentResponseFull getAiAgentById(String agentId, GetAiAgentByIdHeaders headers) {
199	return getAiAgentById(agentId, new GetAiAgentByIdQueryParams(), headers);	×
200	}
201
202	/**
203	* Gets an AI Agent using the `agent_id` parameter.
204	*
205	* @param agentId The agent id to get. Example: "1234"
206	* @param queryParams Query parameters of getAiAgentById method
207	* @param headers Headers of getAiAgentById method
208	*/
209	public AiSingleAgentResponseFull getAiAgentById(
210	String agentId, GetAiAgentByIdQueryParams queryParams, GetAiAgentByIdHeaders headers) {
211	Map<String, String> queryParamsMap =	1✔
212	prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));	1✔
213	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
214	FetchResponse response =	1✔
215	this.networkSession
216	.getNetworkClient()	1✔
217	.fetch(	1✔
218	new FetchOptions.Builder(
219	String.join(	1✔
220	"",
221	this.networkSession.getBaseUrls().getBaseUrl(),	1✔
222	"/2.0/ai_agents/",
223	convertToString(agentId)),	1✔
224	"GET")
225	.params(queryParamsMap)	1✔
226	.headers(headersMap)	1✔
227	.responseFormat(ResponseFormat.JSON)	1✔
228	.auth(this.auth)	1✔
229	.networkSession(this.networkSession)	1✔
230	.build());	1✔
231	return JsonManager.deserialize(response.getData(), AiSingleAgentResponseFull.class);	1✔
232	}
233
234	/**
235	* Deletes an AI agent using the provided parameters.
236	*
237	* @param agentId The ID of the agent to delete. Example: "1234"
238	*/
239	public void deleteAiAgentById(String agentId) {
240	deleteAiAgentById(agentId, new DeleteAiAgentByIdHeaders());	1✔
241	}	1✔
242
243	/**
244	* Deletes an AI agent using the provided parameters.
245	*
246	* @param agentId The ID of the agent to delete. Example: "1234"
247	* @param headers Headers of deleteAiAgentById method
248	*/
249	public void deleteAiAgentById(String agentId, DeleteAiAgentByIdHeaders headers) {
250	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
251	FetchResponse response =	1✔
252	this.networkSession
253	.getNetworkClient()	1✔
254	.fetch(	1✔
255	new FetchOptions.Builder(
256	String.join(	1✔
257	"",
258	this.networkSession.getBaseUrls().getBaseUrl(),	1✔
259	"/2.0/ai_agents/",
260	convertToString(agentId)),	1✔
261	"DELETE")
262	.headers(headersMap)	1✔
263	.responseFormat(ResponseFormat.NO_CONTENT)	1✔
264	.auth(this.auth)	1✔
265	.networkSession(this.networkSession)	1✔
266	.build());	1✔
267	}	1✔
268
269	public Authentication getAuth() {
270	return auth;	×
271	}
272
273	public NetworkSession getNetworkSession() {
274	return networkSession;	×
275	}
276
277	public static class Builder {
278
279	protected Authentication auth;
280
281	protected NetworkSession networkSession;
282
283	public Builder() {	1✔
284	this.networkSession = new NetworkSession();	1✔
285	}	1✔
286
287	public Builder auth(Authentication auth) {
288	this.auth = auth;	1✔
289	return this;	1✔
290	}
291
292	public Builder networkSession(NetworkSession networkSession) {
293	this.networkSession = networkSession;	1✔
294	return this;	1✔
295	}
296
297	public AiStudioManager build() {
298	return new AiStudioManager(this);	1✔
299	}
300	}
301	}

box / box-java-sdk / #5076

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