API manual

Med Reqtests API kan du skapa lösningar för att:

Integrera ditt testautomationsverktyg med Reqtest
Skapa felrapporter från den applikation eller det system som du testar
Skapa en testkörning / testfall och exekvera testfallen i en testkörning
Synkronisera data med andra kravhanterings verktyg

Vad kan du göra med API

Reqtests API stödjer följande:

Skapa, läsa och uppdatera krav, testfall, testsviter, testkörningar och felrapporter
Arbeta med kommentarer och bilagor
Lägga till, uppdatera och exekvera innehåll i testkörningar
Radering av krav, testfall, testkörningar, testsviter och felrapporter
Arkivering av krav, testfall, testsviter och felrapporter
Länkning av data som till exempel länkning av testfall med krav
Läsa och skapa användare

Genom att integrera andra verktyg med Reqtest kan du maximera värdet av Reqtest. Du kan till exempel skapa en integration med ditt testautomationsverktyg så att du kan planera och följa upp både manuella tester och automatiserade tester i Reqtest.

Kom igång med API

Följ nedanstående steg för att skapa en integration:

1. Skapa en personlig nyckel (PAT)

2. Aktivera API för ett projekt

3. Testa konfigureringen

4. Utforska end points

5. Implementera en integration

1. Skapa en personlig nyckel (Personal Access Token, PAT)

Din personliga nyckel (PAT) hör ihop med ditt användarkonto i Reqtest. Nyckeln är ditt lösenord för åtkomst till din Reqtest-licens och används vid autentisering för Reqtests API. Nyckeln fungerar som ett lösenord som ger åtkomst till din Reqtest-licens och används vid autentisering för Reqtest API. Nyckeln genereras automatiskt och visas endast när du skapar den. Du behöver därför kopiera nyckeln och spara den på ett säkert ställe.

Av säkerhetsskäl har en nyckel begränsad giltighetstid (upp till ett år). När en nyckels giltighetstid passeras upphör den att fungera. En integration behöver en giltig nyckel för att fungera, därför behöver du skapa en ny nyckel när den gamla går ut. Konfigurera dina integrationer på nytt så att de använder den nya giltiga nyckeln i stället för den som är utgången.

För att skapa en nyckel (PAT) behöver du ha behörighetsnivå Projektadministratör eller Administratör i Reqtest. Så här gör du för att skapa en PAT:

1.1 I Reqtest, klicka på pilen bredvid din användarprofil högst upp till höger och klicka sedan på knappen Inställningar.

1.2 Klicka på kugghjulet för inställningar och sedan på fliken API Åtkomst.

1.3 Klicka på ikonen med plus-tecken för att skapa en PAT. Namnge nyckeln och ange giltighetstid. Bekräfta.

1.4 När du skapar en nyckel behöver du kopiera den och spara den på ett säkert sätt så att du kan använda den senare. Av säkerhetsskäl kommer nycken inte att visas fler gånger.

När en web request skapas till API behöver PAT finnas med i Reqtest-PAT header. Om du använder en browser kommer du att bli ombedd att ange användarnamn och lösenord. Du ska ange din PAT i fältet för lösenord. Lämna fältet för användarnamn tomt.

En projektadministratör kan generera en PAT-logg (senaste 2 åren) för att få information om vilken typ av åtgärder som utförs i projektet tillsammans med användaren och den token som används vid ett visst datum. Du hittar knappen visa åtkomstlogg på fliken Integration> konfigurering av API.

Återkalla PAT

Om din PAT inte längre är i bruk eller om du vill undvika att någon annan använder den kan du återkalla nyckeln. Så här gör du för att återkalla en PAT:

1. Gå till din användarprofil uppe i högra hörnet och klicka på kugghjulet för att komma till inställningar

2. Klicka på fliken API Åtkomst

3. Markera den PAT som du vill återkalla och klicka på soptunnan till höger

4. Ett popup-fönster öppnas och du måste bekräfta för att radera de valda personaliga tokens

2. Aktivera API för ett projekt

För att kunna integrera till ett projekt behöver du aktivera API för det projektet.

Gör så här för att aktivera API för ett Reqtest-projekt:

1. Klicka på projektväljaren i rullgardinslistan och klicka på kugghjulet för det projekt som ska ha en integration

2. Klicka på fliken Integrationer

3. Klicka på fliken Konfigurering av API

4. Använd knappen för att Aktivera API

5. Bekräfta

Aktivering av API sker per projekt för att garantera att endast projekt som du själv väljer kan nås via API.

Se en kort video om hur du konfigurerar Reqtest. Lär dig att skapa en personlig nyckel och aktivera API i ett projekt för att förbereda inför en integration.

3. Testa konfigureringen

För att testa din konfigurering behöver du respektive ärendes ID-nummer så att du kan referera till de önskade ärendena. ID för varje ärende finns på respektive ärendes sida. För att testa konfigureringen för PAT och projektet behöver du veta projektets id. Du behöver ha behörighetsnivå Projekt administratör eller Administratör i ReQtest för att se id för projekten. Följ stegen nedan för att ta reda på id för ditt ReQtest-projekt:

Logga in i ReQtest
Klicka på fliken Administration
Klicka på fliken Projekt för att se listan med projekt. Välj ett projekt och klicka på det för att se detaljer om projektet. Längst ner på sidan Projektdetaljer ser du Projekt-ID.

Nu kan du hämta projektet genom att använda API. Gå till projektet

https://secure.reqtest.com/api/v3/projects/<project ID> via din webbläsare (Exempel: om id för ditt projekt är 123, gå till https://secure.reqtest.com/api/v3/projects/123). När du blir ombedd att fylla i inloggningsuppgifter, gör så här: lämna fältet användarnamn tomt, fyll i din personliga nyckel (PAT) i fältet för lösenord. Webbsidan som öppnas visar information om projektet.

Exempel på svar::{
”id”: 8464,
”name”: ”5000 test project”
”projectPermissionLevel”: ”Admin”
}

4. Utforska end points

Hjälpsidorna om API beskriver hur du kan använda Reqtest API. Du hittar en lista över alla end points som du kan använda för att interagera med Reqtest. Du ser också vilken information du kan skicka och vad du kan förvänta dig att få i retur när du använder olika end points.

I Reqtest finns ett antal olika behörigheter som dina användare kan ha. Läs mer nedan om vad de kan göra.

5. Implementera en integration

Nu när du vet vilka end points du ska använda kan du bygga en applikation som använder dessa. Du kan skapa och skicka web requests och läsa responses på många olika språk såsom t.ex. JAVA, Python, .Net.

API funktioner

För att säkerställa att API:et ger snabba och stabila svar erbjuder vi funktionerna nedan. De förkortar svarstiden och förbättrar upplevelsen för användaren.

Svarsantal: Begränsar antalet svar per fråga så att inte allt skickas samtidigt.
Filtrering och sortering: Få bara de resultat du behöver och få dem dessutom i rätt ordning.
Utökning: Få resultat som endast innehåller det som är relevant för dig.

Svarsantal

När du efterfrågar en stor mängd data från API:et kan prestandan påverkas. Därför är antalet ärenden som skickas samtidigt begränsat till 20. Om listan med ärenden inte innehåller samtliga efterfrågade ärenden kommer en URL att förse API:et med de resterande ärendena.

För att kontrollera i detalj vilka ärenden som hämtas kan du använda variablerna offset och count i din query string.

Exempel:

Du vill få de första 100 felrapporterna för ett projekt med ID123:
https://secure.reqtest.com/api/v3/projects/123/bugs?count=100

Du vill få felrapporterna 201 till 300:
https://secure.reqtest.com/api/v3/projects/123/bugs? offset=200&count=100

Filtrering och sortering

I / query-slutpunkterna kan du definiera valfritt antal filter och 1 sorteringsordning. Fälten ”filterOn” och ”sortOn” används för att ange vilken del av resultatet som ska filtreras eller sorteras, till exempel ”filterOn”: ”createdDate” eller ”sortOn”: ”id”.

För att filtrera eller sortera efter egenskaper som finns i objekt, ’.’ separator ska användas. Till exempel:

när du filtrerar objekt som har en bilaga med ett specifikt filnamn: ”filterOn”: ”attachments.fileName”.
för att hitta objekt som är länkade till ett krav: ”filterOn”: ”links.requirements.id”

Fält har ett komplext objekt där värdetypen beror på fälttypen. För att hålla det enkelt fungerar filtrering och sortering på fält på samma sätt som i ReQtest-applikationen. Du kan till exempel filtrera på:

Namnet på en felrapport: {”filterOn”: ”fields.Heading”, ”fitlerFor”: ”performance”}.
Värdet på status: {”filterOn”: ”fields.Status”, ”fitlerFor”: ”In Progress”}.

Observera att fältnamn är skiftlägeskänsliga.

Fält har många olika typer och varje typ kan filtreras på olika sätt. ”FilterFor” accepterar samma värden som filter i ReQtest-applikationen. Du kan skapa filter där och använda dem för dina API-frågor.

För fält som är en text eller en uppsättning värden (rullgardins- och användarfält) kan du använda ett textfilter:

Textfilter får inte innehålla ”;”. Till exempel: {”filterOn”: ”fields.Heading”, ”filterFor”: ”invoicing”}.
För fält utan värden: ”filterFor”: ”[Empty];”.
För fält som innehåller ett värde: ”filterFor”: ”[Not]; [Empty];”.
För fält som inte innehåller en text: ”filterFor”: ”[Not]; slutfört”.

För fält som är en uppsättning värden kan du filtrera efter exakt text eller ID.

För att filtrera efter exakta texter bör texten avslutas med ett ’;’. Till exempel: {”filterOn”: ”fields.Status”, ”fitlerFor”: ”New; In Progress;”}.
För att filtrera efter id, använd id och avsluta med ett ’;’, såsom: ”filterFor”: ”12345; 12346;”. ID-värdena för värden finns i / meta-slutpunkten.
Nyckelorden [Not] och [Empty] kan också användas här: ”filterFor”: ”[Not]; [Empty]; 12345;”

I ReQtest finns det två typer av datum: datumfält som kan konfigureras och datum för ”createdDate”, ”changedDate” and ”executionDate”.

Datumfält stöder endast formatet yyyy-MM-dd (exempel: 2021-10-31). Dessa datum är utan tid och stöder inte tidszoner.
Datum för att ”createdDate”, ”changedDate” and ”executionDate” har tid och är tidszonspecifika. De returneras i UTC och format i ISO 8601 (exempel: 2021-10-31T09:20Z). För dessa datum är det inte möjligt att filtrera för en specifik tid, men intervall är tillåtna. Vid filtrering kan tiden utelämnas för att indikera midnatt (exempel: 2021-10-31Z). Om tidszonen utelämnas används serverns tidszon.

Datumfilter fungerar på samma sätt som de fungerar i applikationen:

För att filtrera på ett datumintervall separeras från och till datum med ’|’: {”filterOn”: ”createdDate”, ”filterFor”: ”2021-04-10|2021-04-30”}.
Från eller till datum kan utelämnas för att söka efter objekt som är äldre än eller nya än sökdatumet: ”filterFor”: ”|2021-04-30”
För datumfält kan du söka efter ett specifikt datum: {“filterOn”: “MyDateField”, “filterFor”: “2021-04-10”}. Detta kan endast användas för anpassade datumfält. Det stöds inte för ”createdDate”, ”changedDate” and ”executionDate”.
För att filtrera på ett datum som är de senaste x dagarna (d), veckorna (w), månaderna (m) eller åren (y) kan filtret appliceras precis som i applikationen. För den senaste månaden använd: ”filterFor”: ”1m”.

För id eller numeriska fält kan du söka efter:

enstaka värden åtskilda av ’;’, såsom: {”filterOn”: ”customId”, ”filterFor”: ”1; 3; 5”}.
ett värdeintervall med ’-’, såsom: ”filterFor”: ”3-8”
en kombination av filter: ”filterFor”: ”1; 3-8; 12”

För den booleska egenskapen ”arkiverad” accepteras värdena true, false, 0 och 1.

Utökning

När du frågar efter ärenden returneras inte alla data. Vissa egenskaper som är en lista med objekt (såsom kommentarer och bifogade filer) returneras endast om du specifikt efterfrågar dem. För detta används variabeln expand i query string för att utöka sökningen. Om du till exempel vill få med kommentarer till kravet kan denna formulering användas:

https://secure.reqtest.com/api/v3/projects/123/requirements?expand=comments

Du kan utöka frågan med flera egenskaper. Vid en sådan utökad fråga, där flera egenskaper efterfrågas, behöver de vara separerade med kommatecken:

https://secure.reqtest.com/api/v3/projects/123/requirements?expand=comments,attachments

Det är också möjligt att fråga efter flera egenskaper genom att använda *:

https://secure.reqtest.com/api/v3/projects/123/requirements?expand=*

I de fall du vet exakt vilka fält du vill ska returneras kan du använda fältens namn id inom parentes. Du kan också fråga efter alla fält genom att använda *:

https://secure.reqtest.com/api/v3/projects/123/bugs?expand=fields(Status,Priority)

https://secure.reqtest.com/api/v3/projects/123/bugs?expand=fields(*)

Beträffande länkar kan du specificera vilken typ av länkar du vill ska returneras. Notera dock att du inte kan få fler detaljer i links:

https://secure.reqtest.com/api/v3/projects/123/testcases?expand=links(requirements,bugs)

I följande exempel är links(bugs) tillåtet, men (*) är inte tillåtet:

https://secure.reqtest.com/api/v3/projects/123/testcases?expand=links(bugs(*))

Genom att använda expand vid testkörningar kan du inkludera testfall och teststeg:

https://secure.reqtest.com/api/v3/projects/123/testruns?expand=contents(testcase(fields(*)))

https://secure.reqtest.com/api/v3/projects/123/testruns?expand=contents(steps(attachments))

https://secure.reqtest.com/api/v3/projects/123/testruns?expand=contents(testcase(fields(*)),steps(attachments))

Du kan kombinera flera olika egenskaper genom att ange dem separerade med kommatecken:

https://secure.reqtest.com/api/v3/projects/123/bugs?expand=fields(Status,Priority),attachments,comments

Alla API-metoder hittar du via den här länken

API Binding: Java

Java and Java-based languages will use the API binding for Java to access Reqtest’s API. It has the fundamental features of reading and writing requests, as well as for JSON encoding and decoding.

Here are few examples of how to use the API binding:

The provided code sample below is a web-application written in Java (Spring Boot) and demonstrates basic functionality for fetching and updating bugs from ReQtest using the REST version of the API.

ZIP Link to download code

Setup & installation

Extract the ZIP file from the above location to a directory of your choice. The Java binding can be found in the “java” subdirectory after active download/extraction. Add the included kit to your project or program. In your preferred IDE, you can create or import a new project (e.g. in Eclipse).

File -> Import -> Existing Maven Project -> Next -> Browse -> Select the project -> Finish

The java binding uses the spring framework’s RestTemplate, HttpHeaders, HttpEntity, ResponseEntity to make external HTTP calls and curate the response.

Example: GET request

Read-only API methods use GET requests, which can be used to read from ReQtest.

For example- the code below demonstrates how to use the “get bugs” API method to get a list of existing bugs in the system.

HttpHeaders headers = new HttpHeaders();

headers.set(“accept”, “application/json”);
headers.set(“reqtest-pat”, 0s4h9fjrjj…);

HttpEntity entity = new HttpEntity(headers);

return restTemplate.exchange(
url = “https://” + putYourProjectId + “/bugs”,
HttpMethod.GET, entity, String.class).getBody();

For GET requests, the API binding provides a single method called “getData,” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project). The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception will be thrown. Your code should be prepared to handle the exception.

Example: POST request

Write-based API methods use POST requests, which can be used to add or modify data in ReQtest.

For example- the code below demonstrates how to use the “create bugs” API method to create bugs in the system.

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.APPLICATION_JSON);
headers.set(“accept”, “application/json”);
headers.set(“reqtest-pat”, 0s4h9fjrjj…);

HttpEntity entity = new HttpEntity(reqBody, headers);

ResponseEntity result = restTemplate.exchange(
“https://” + putYourProjectId + “/bugs”,
HttpMethod.POST, entity, String.class);

return ResponseEntity.ok().body(result.getBody().toString());

For POST requests, the API binding provides a single method called “postData,” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project) and also request body (in this case bug details). The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception will be thrown, and your code should be prepared to handle it.

Example: Attachment Request

Upload and download API bindings can be used for adding an attachment to ReQtest or retrieving an attachment from ReQtest respectively.

For example- the code below demonstrates how to use the “download and upload” attachment API endpoints for Bugs module.

For download requests, the API binding provides single methods called “downloadData” for retrieving an attachment from ReQtest. This method expects the user’s PAT as well as any possible query parameters (in this case Project ID, Bug ID, and Attachment ID in a specific order in the URL). The file will be downloaded to the provided “downloadPath” in the code snippet below.

HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
headers.set(“accept”, “application/json”);
headers.set(“reqtest-pat”, 0s4h9fjrjj…);

HttpEntity entity = new HttpEntity(headers);

ResponseEntity<byte[]> response = restTemplate
.exchange(
“https://” + putYourProjectId + “/bugs/attachments/” + attachmentId + “/download”,
HttpMethod.POST, entity, byte[].class, “1”);

String encodedStr = Base64.getEncoder().encodeToString(response.getBody());
String downloadPath = “D:/download/fileName.jpg”; // download path followed by file name

if (response.getStatusCode() == HttpStatus.OK) {
Files.write(Paths.get(downloadPath), response.getBody());
}

For upload requests, the API binding provides single methods called “uploadData” for uploading an attachment from ReQtest. This method expects the user’s PAT as well as any possible query parameters (in this case Project ID and Bug ID in a specific order in the URL). This is a POST API with content media-type as multipart/form-data which is standard industry format for upload APIs. The file to upload shall be picked from the provided “uploadFile” path with file name.

String uploadFile = “D:/upload/fileToUpload.jpg”; // upload path followed by file name

HttpHeaders headers = new HttpHeaders();
headers.set(“Content-Type”, “multipart/form-data”);
headers.set(“Accept”, “text/plain”);
headers.set(“reqtest-pat”, 0s4h9fjrjj…);

MultiValueMap<String, Object> bodyMap = new LinkedMultiValueMap<>();

API Binding: Net

.Net and .Net-based languages will use the API binding for .Net to access ReQtest’s API. It has the fundamental features of reading and writing requests, as well as for JSON encoding and decoding.

Here are few examples of how to use the API binding:

The provided code sample below is a console application written in C# and demonstrates basic functionality for fetching and updating bugs from ReQtest using the REST version of the API.

ZIP Link to download code

Setup & installation

Extract the ZIP file from the above location to a directory of your choice. The .Net binding can be found in the “.Net” subdirectory after active download/extraction. Add the included kit to your project or program. In your preferred IDE, you can create or open a new project (e.g. in Visual studio).
File -> Open-> Project/Solution… -> Browse -> Select the project -> Open
Binding uses the .Net framework’s HttpClient, HttpResponseMessage to make external HTTP calls and curate the response.

Example: GET request
Use GET requests to read data from ReQtest.
For example- the code below demonstrates how to use the “get bugs” API method to get a list of existing bugs in the system.

Read-based API methods use GET requests, the API binding provides a single method called “GetBugs,” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project). The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception will be thrown. Your code should be prepared to handle the exception.

Example: POST request
Write-based API methods use POST requests, which can be used to add or modify data in ReQtest.
For example- the code below demonstrates how to use the “create bugs” API method to create bugs in the system.

string url = string.Format(”{0}/api/v3/projects/{1}/bugs”, hostName, projectId);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(”application/json”));
client.DefaultRequestHeaders.Add(”reqtest-pat”, patToken);
//Sample Json for Create a bug
var model = @”{
””fields””:{
””Heading””:{””name”” : ””Heading””, ””value”” : ””Title of Bug””},
””ErrorDescription””:{””name”” : ””ErrorDescription””, ””value”” : ””Error Description of Bug””}
}
}”;StringContent content = new StringContent(model, System.Text.Encoding.UTF8, ”application/json”);
var response = client.PostAsync(url, content).GetAwaiter().GetResult();
Console.WriteLine(”POST Bug API Executed”);
if (response.IsSuccessStatusCode)
{
Console.WriteLine(”Success”);
var result = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Console.WriteLine(result);
}
else
{
Console.WriteLine(”Failed”);
var result = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Console.WriteLine(result);
}
}

For POST requests, the API binding provides a single method called “CreateBug” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project) and also request body (in this case bug details). The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception will be thrown, and your code should be prepared to handle it.

Example: Attachment Request
Upload and download API bindings can be used for adding an attachment to ReQtest or retrieving an attachment from ReQtest respectively.

For example- the code below demonstrates how to use the “download and upload” attachment API endpoints for Bugs module.

For download requests, the API binding provides single methods called “DownloadBugAttachment” for retrieving an attachment from ReQtest. This method expects the user’s PAT as well as any possible query parameters (in this case Project ID, Bug ID, and Attachment ID in a specific order in the URL). The file will be downloaded to the provided “downloadPath” in the code snippet below.

string url = string.Format(”{0}/api/v3/projects/{1}/bugs/{2}/attachments/{3}/download”, hostName, projectId, bugId, attachmentId);using (var client = new HttpClient())

{
client.DefaultRequestHeaders.Accept.Clear();
//Set Content Type
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(”application/json”));//Set Header Value
client.DefaultRequestHeaders.Add(”reqtest-pat”, patToken);

//Set File Object

using (var response = client.GetAsync(url).GetAwaiter().GetResult())
{
Console.WriteLine(”Download Bug attachment API Executed”);
if (response.IsSuccessStatusCode)
{
Console.WriteLine(”Success”);
using (var result = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult())
{
using (var fileStream = File.Create(dowloadPath))
{
using (var reader = new StreamReader(result))
{
result.CopyTo(fileStream);
fileStream.Flush();
Console.WriteLine(”File Download Successfully”);
}
}

}
}
else
{
Console.WriteLine(”Failed”);
var result = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Console.WriteLine(result);
}
}
}

For upload requests, the API binding provides single methods called “UploadBugAttachment” for uploading an attachment from ReQtest. This method expects the user’s PAT as well as any possible query parameters (in this case Project ID and Bug ID in a specific order in the URL). This is a POST API with content media-type as multipart/form-data which is the standard industry format for upload APIs. The file to upload shall be picked from the provided “uploadPath” path with the filenamefile name.

string url = string.Format(”{0}/api/v3/projects/{1}/bugs/{2}/attachments”, hostName, projectId, bugId);FileStream fileStreamObject = File.OpenRead(uploadPath);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
//Set Content Type
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(”multipart/form-data”));//Set Header Value
client.DefaultRequestHeaders.Add(”reqtest-pat”, patToken);

//Initialize the form
using (var form = new MultipartFormDataContent())
{
//Set File Object
form.Add(content: new StreamContent(fileStreamObject), name: Path.GetFileName(uploadPath), fileName: Path.GetFileName(uploadPath));

using (var response = client.PostAsync(url, form).GetAwaiter().GetResult())
{
Console.WriteLine(”Upload Bug Attachment API Executed”);
if (response.IsSuccessStatusCode)
{
Console.WriteLine(”Success”);
var result = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Console.WriteLine(result);
}
else
{
Console.WriteLine(”Failed”);
var result = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
Console.WriteLine(result);
}
}
}
}

API binding: Python

Python-based frameworks will use the API binding for Python to access ReQtest’s API. It has the fundamental features of reading and writing requests, as well as smooth JSON encoding and decoding. Several examples of how to use the API binding can be found below.

The provided code sample below is a web-application written in Python (flask) and demonstrates basic functionality for fetching and updating bugs from ReQtest using the REST version of the API.

ZIP Link to download code

Setup & installation

Extract the ZIP file from the above location to a directory of your choice. The Python binding can be found in the “python” subdirectory after active download/extraction. Add the included kit to your project or program. In your preferred IDE, you can create or import a new project. The python binding uses flask and requests modules to make external HTTP calls and curate the response.

Example: GET request

Read-only API methods use GET requests, which can be used to read from ReQtest. For example- the code below demonstrates how to use the “get bugs” API method to get a list of existing bugs in the system (it will be a link to bugs with get bugs expanded).

headers = {
”Content-Type” : ”application/json”,
”accept”: ”application/json”,
”reqtest-pat”: 0s4h9fjrjj…,
”User-Agent”: ”Custom”
}
result = requests.get(
url = ”https://” + putYourProjectId + ”/bugs”,
headers = headers)

For GET requests, the API binding provides a single method called ”getData,” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project). The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception can be thrown. Your code should be prepared to handle the exception.

Example: POST request

Write-based API methods use POST requests, which can be used to add or modify data into ReQtest. For example- the code below demonstrates how to use the “create bugs” API method to create bugs in the system (this will be linked to bugs with ’create bugs’ expanded).

headers = {
”Content-Type” : ”application/json”,
”accept”: ”application/json”,
”reqtest-pat”: 0s4h9fjrjj…,
”User-Agent”: ”Custom”
}
result = requests.post(
url = ”https://” + putYourProjectId + ”/bugs”,
headers = headers,
json = request.json)

For POST requests, the API binding provides a single method called ”postData,” which expects the user’s PAT as well as any possible query parameters (in this case the ID of the project) and also request body (in this case bug details).

The return value is a simple object (an instance of JSONObject or JSONArray).

In the event of an error (connection problems, failed authentication, missed API arguments, etc. ), an exception can be thrown. Your code should be prepared to handle the exception.

Example: Attachment Request

Upload and download API bindings can be used for adding an attachment to ReQtest or retrieving an attachment from ReQtest respectively.

For example- the code below demonstrates how to use the “download and upload” attachment API endpoints for Bugs module.

For download requests, the API binding provides single methods called downloadData for retrieving an attachment from ReQtest. Which expects the user’s PAT as well as any possible query parameters (in this case Project ID, Bug ID, and Attachment ID in a specific order in the URL).

headers = {

”Content-Type” : ”application/json”,
”User-Agent”: ”Custom”,
”reqtest-pat”: 0s4h9fjrjj…,
}
r = requests.get(
url = ”https://” + putYourProjectId + ”/bugs/attachments/” + attachmentId + ”/download”,
headers = headers,
allow_redirects=True)

base64data = base64.b64encode(r.content).decode(”utf-8”)

downloadPath = ”D:/download/fileName.jpg”; // download path followed by file name

if r.status_code == 200:
with open(downloadPath, ’wb’) as f:
f.write(r.content)

For upload requests, the API binding provides single methods called uploadData for uploading an attachment from ReQtest. This method expects the user’s PAT as well as any possible query parameters (in this case Project ID and Bug ID in a specific order in the URL). This is a POST API with content media-type as multipart/form-data which is standard industry format for upload APIs.

headers = {
”accept”: ”application/json”,
”User-Agent”: ”Custom”,
”reqtest-pat”: 0s4h9fjrjj…
}
uploadFile = ”D:/upload/fileToUpload.jpg”; // upload path followed by file name

result = requests.post(
url = ”https://” + putYourProjectId + ”/bugs/attachments/” + attachmentId,
files = { ”file”: open(uploadFilePath, ”rb”) },
headers = headers
)

Vanliga frågor och svar om API

Vad är rate-limiting?

Vad är standard antalet för de poster som returneras?

Hur kan jag få fältinformation?

Hur kan jag gruppera värdet i ett rullgardinsfält?

Hur laddar jag upp en bilaga till något objekt, dvs. krav, testfall?

Vilket datumformat används av API:t?

API manual

Vad kan du göra med API

Kom igång med API

1. Skapa en personlig nyckel (Personal Access Token, PAT)

Återkalla PAT

2. Aktivera API för ett projekt

3. Testa konfigureringen

4. Utforska end points

5. Implementera en integration

API funktioner

Svarsantal

Filtrering och sortering

Utökning

API Reference

API Binding: Java

Setup & installation

API Binding: Net

Setup & installation

API binding: Python

Setup & installation

Vanliga frågor och svar om API