✅ Please help me read this simple API endpoint documentation

Gipper · 2024-04-24T17:36:30.632Z

So the image I included is a sample of one of the rows in a table that is supposed to be the documentation of the endpoints of an API I have to write Unit and Integration tests for. I do not have access to the code (as it probably doesn't even exist or at least not fully) and I don't know much about how the application will end up in terms of codebase or in terms of final software produced. This documentation is in reference to the API endpoints of the backend of a web app that will be developed in ASP.NET (at least the backend part will be in ASP). What I need help with is in understanding better what an API endpoint is and what it does in this context. Also how that connects with the info on this table. Finally, I also need to know how I can use all that information once I understand it and understand how it all is interrelated to make these unit and integration tests (I'm doing integration right now, cause no code yet).

G

GipperOP•4/24/24, 5:37 PM

As a clarification, I can switch back to doing unit tests if you think even with having no code I can make them with just this info, that just wasn't what I was planning but whatever it's completely fine either way.

A

Angius•4/24/24, 5:37 PM

An API endpoint is the code that handles a given HTTP call

A

Angius•4/24/24, 5:38 PM

In this case, a

GET

GET

call to

https://some-website.com/User/john@gmail.com

https://some-website.com/User/john@gmail.com

https://some-website.com/User/john@gmail.com

https://some-website.com/User/john@gmail.com

A

Angius•4/24/24, 5:38 PM

Which is supposed to return that user's data

A

Angius•4/24/24, 5:38 PM

Their ID, username, and state

A

Angius•4/24/24, 5:40 PM

Something like

// UserController.cs
[Route("[controller]")]
class UserController : ControllerBase
{
    [HttpGet("{email}")]
    public async Task<IActionResult> GetUserByEmail(string email)
    {
        var user = await _context.Users
            .Where(u => u.Email == email)
            .Select(u => new UserDataDto {
                Id = u.Id,
                Username = u.Username,
                State = u.State
            })
            .FirstOrDefaultAsync();
        return user is null ? NotFound() : Ok(user);
    }
}

// UserController.cs
[Route("[controller]")]
class UserController : ControllerBase
{
    [HttpGet("{email}")]
    public async Task<IActionResult> GetUserByEmail(string email)
    {
        var user = await _context.Users
            .Where(u => u.Email == email)
            .Select(u => new UserDataDto {
                Id = u.Id,
                Username = u.Username,
                State = u.State
            })
            .FirstOrDefaultAsync();
        return user is null ? NotFound() : Ok(user);
    }
}

// UserController.cs
[Route("[controller]")]
class UserController : ControllerBase
{
    [HttpGet("{email}")]
    public async Task<IActionResult> GetUserByEmail(string email)
    {
        var user = await _context.Users
            .Where(u => u.Email == email)
            .Select(u => new UserDataDto {
                Id = u.Id,
                Username = u.Username,
                State = u.State
            })
            .FirstOrDefaultAsync();
        return user is null ? NotFound() : Ok(user);
    }
}

// UserController.cs
[Route("[controller]")]
class UserController : ControllerBase
{
    [HttpGet("{email}")]
    public async Task<IActionResult> GetUserByEmail(string email)
    {
        var user = await _context.Users
            .Where(u => u.Email == email)
            .Select(u => new UserDataDto {
                Id = u.Id,
                Username = u.Username,
                State = u.State
            })
            .FirstOrDefaultAsync();
        return user is null ? NotFound() : Ok(user);
    }
}

A

Angius•4/24/24, 5:46 PM

A

Angius•4/24/24, 5:47 PM

Unit tests without having the code are not really possible

A

Angius•4/24/24, 5:47 PM

Integration tests... are more possible

AAngius Integration tests... are more possible

G

GipperOP•4/24/24, 5:56 PM

Ok, so integration then. I ran this exact same info by chatGPT and asked for integration tests and this is what it said:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Net.Http;
using System.Threading.Tasks;

namespace YourTestProjectNamespace
{
    [TestClass]
    public class UserIntegrationTests
    {
        private readonly HttpClient _httpClient;
        private const string BaseUrl = "http://your-api-base-url"; // Update this with your actual API base URL

        public UserIntegrationTests()
        {
            _httpClient = new HttpClient();
        }

        [TestMethod]
        public async Task GetUserById_ReturnsCorrectUser()
        {
            // Arrange
            var userId = "1";
            var expectedUser = new { id = "1", username = "Tom", state = "0" };

            // Act
            var response = await _httpClient.GetAsync($"{BaseUrl}/User/{userId}");
            response.EnsureSuccessStatusCode(); // Throw an exception if HTTP status code is not success

            var actualUser = await response.Content.ReadAsAsync<dynamic>();

            // Assert
            Assert.AreEqual(expectedUser.id, actualUser.id);
            Assert.AreEqual(expectedUser.username, actualUser.username);
            Assert.AreEqual(expectedUser.state, actualUser.state);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Net.Http;
using System.Threading.Tasks;

namespace YourTestProjectNamespace
{
    [TestClass]
    public class UserIntegrationTests
    {
        private readonly HttpClient _httpClient;
        private const string BaseUrl = "http://your-api-base-url"; // Update this with your actual API base URL

        public UserIntegrationTests()
        {
            _httpClient = new HttpClient();
        }

        [TestMethod]
        public async Task GetUserById_ReturnsCorrectUser()
        {
            // Arrange
            var userId = "1";
            var expectedUser = new { id = "1", username = "Tom", state = "0" };

            // Act
            var response = await _httpClient.GetAsync($"{BaseUrl}/User/{userId}");
            response.EnsureSuccessStatusCode(); // Throw an exception if HTTP status code is not success

            var actualUser = await response.Content.ReadAsAsync<dynamic>();

            // Assert
            Assert.AreEqual(expectedUser.id, actualUser.id);
            Assert.AreEqual(expectedUser.username, actualUser.username);
            Assert.AreEqual(expectedUser.state, actualUser.state);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Net.Http;
using System.Threading.Tasks;

namespace YourTestProjectNamespace
{
    [TestClass]
    public class UserIntegrationTests
    {
        private readonly HttpClient _httpClient;
        private const string BaseUrl = "http://your-api-base-url"; // Update this with your actual API base URL

        public UserIntegrationTests()
        {
            _httpClient = new HttpClient();
        }

        [TestMethod]
        public async Task GetUserById_ReturnsCorrectUser()
        {
            // Arrange
            var userId = "1";
            var expectedUser = new { id = "1", username = "Tom", state = "0" };

            // Act
            var response = await _httpClient.GetAsync($"{BaseUrl}/User/{userId}");
            response.EnsureSuccessStatusCode(); // Throw an exception if HTTP status code is not success

            var actualUser = await response.Content.ReadAsAsync<dynamic>();

            // Assert
            Assert.AreEqual(expectedUser.id, actualUser.id);
            Assert.AreEqual(expectedUser.username, actualUser.username);
            Assert.AreEqual(expectedUser.state, actualUser.state);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Net.Http;
using System.Threading.Tasks;

namespace YourTestProjectNamespace
{
    [TestClass]
    public class UserIntegrationTests
    {
        private readonly HttpClient _httpClient;
        private const string BaseUrl = "http://your-api-base-url"; // Update this with your actual API base URL

        public UserIntegrationTests()
        {
            _httpClient = new HttpClient();
        }

        [TestMethod]
        public async Task GetUserById_ReturnsCorrectUser()
        {
            // Arrange
            var userId = "1";
            var expectedUser = new { id = "1", username = "Tom", state = "0" };

            // Act
            var response = await _httpClient.GetAsync($"{BaseUrl}/User/{userId}");
            response.EnsureSuccessStatusCode(); // Throw an exception if HTTP status code is not success

            var actualUser = await response.Content.ReadAsAsync<dynamic>();

            // Assert
            Assert.AreEqual(expectedUser.id, actualUser.id);
            Assert.AreEqual(expectedUser.username, actualUser.username);
            Assert.AreEqual(expectedUser.state, actualUser.state);
        }
    }
}

What do you think? If I understand all that is happening can I use it? Is it good code? Can I emulate it for all the other endpoints to the best of my ability?

A

Angius•4/24/24, 5:57 PM

This code tries to get the user by ID and not email, and it used

dynamic

dynamic

dynamic

dynamic

A

Angius•4/24/24, 5:58 PM

So, no, it immediately fails at doing what it's supposed to do

A

Angius•4/24/24, 5:58 PM

I highly recommend not using LLMs if you're just learning

AAngius I highly recommend not using LLMs if you're just learning

G

GipperOP•4/24/24, 6:28 PM

Ok, so I tried to adapt what gpt gave me to this, what do you think?

    [TestFixture]
    public class TestesIntegracaoUser
    {
        private readonly HttpClient _httpClient;
        private const string URLBase = "http://User";

        public TestesIntegracaoUser()
        {
            _httpClient = new HttpClient();
        }
        [OneTimeTearDown]
        public void disposeHTTPClient() 
        {
            _httpClient.Dispose();
        }

        [TestCase("joao@gmail.com")]
        public async Task GetUserByEmail_ReturnsCorrectUser(string email)
        {
            // Arrange
            var userEmail = email;
            var expectedUser = new User { email = userEmail };

            // Act
            var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
            response.EnsureSuccessStatusCode();

            var UserReal = await response.Content.ReadAsStringAsync();

            // Assert
            Assert.AreEqual(expectedUser.id, "1");
            Assert.AreEqual(expectedUser.username, "Tom");
            Assert.AreEqual(expectedUser.id, "0");
        }

    }
    public class User
    {
        public string id;
        public string username;
        public string state;
        public string email;
    }

    [TestFixture]
    public class TestesIntegracaoUser
    {
        private readonly HttpClient _httpClient;
        private const string URLBase = "http://User";

        public TestesIntegracaoUser()
        {
            _httpClient = new HttpClient();
        }
        [OneTimeTearDown]
        public void disposeHTTPClient() 
        {
            _httpClient.Dispose();
        }

        [TestCase("joao@gmail.com")]
        public async Task GetUserByEmail_ReturnsCorrectUser(string email)
        {
            // Arrange
            var userEmail = email;
            var expectedUser = new User { email = userEmail };

            // Act
            var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
            response.EnsureSuccessStatusCode();

            var UserReal = await response.Content.ReadAsStringAsync();

            // Assert
            Assert.AreEqual(expectedUser.id, "1");
            Assert.AreEqual(expectedUser.username, "Tom");
            Assert.AreEqual(expectedUser.id, "0");
        }

    }
    public class User
    {
        public string id;
        public string username;
        public string state;
        public string email;
    }

    [TestFixture]
    public class TestesIntegracaoUser
    {
        private readonly HttpClient _httpClient;
        private const string URLBase = "http://User";

        public TestesIntegracaoUser()
        {
            _httpClient = new HttpClient();
        }
        [OneTimeTearDown]
        public void disposeHTTPClient() 
        {
            _httpClient.Dispose();
        }

        [TestCase("joao@gmail.com")]
        public async Task GetUserByEmail_ReturnsCorrectUser(string email)
        {
            // Arrange
            var userEmail = email;
            var expectedUser = new User { email = userEmail };

            // Act
            var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
            response.EnsureSuccessStatusCode();

            var UserReal = await response.Content.ReadAsStringAsync();

            // Assert
            Assert.AreEqual(expectedUser.id, "1");
            Assert.AreEqual(expectedUser.username, "Tom");
            Assert.AreEqual(expectedUser.id, "0");
        }

    }
    public class User
    {
        public string id;
        public string username;
        public string state;
        public string email;
    }

    [TestFixture]
    public class TestesIntegracaoUser
    {
        private readonly HttpClient _httpClient;
        private const string URLBase = "http://User";

        public TestesIntegracaoUser()
        {
            _httpClient = new HttpClient();
        }
        [OneTimeTearDown]
        public void disposeHTTPClient() 
        {
            _httpClient.Dispose();
        }

        [TestCase("joao@gmail.com")]
        public async Task GetUserByEmail_ReturnsCorrectUser(string email)
        {
            // Arrange
            var userEmail = email;
            var expectedUser = new User { email = userEmail };

            // Act
            var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
            response.EnsureSuccessStatusCode();

            var UserReal = await response.Content.ReadAsStringAsync();

            // Assert
            Assert.AreEqual(expectedUser.id, "1");
            Assert.AreEqual(expectedUser.username, "Tom");
            Assert.AreEqual(expectedUser.id, "0");
        }

    }
    public class User
    {
        public string id;
        public string username;
        public string state;
        public string email;
    }

A

Angius•4/24/24, 6:29 PM

You don't use

UserReal

UserReal

UserReal

UserReal anywhere

A

Angius•4/24/24, 6:29 PM

So what are you checking here? Not the response from the API that's for sure

AAngius So what are you checking here? Not the response from the API that's for sure

G

GipperOP•4/24/24, 6:40 PM

yeah, sorry I had misunderstood:

[TestFixture]
public class TestesIntegracaoUser
{
    private readonly HttpClient _httpClient;
    private const string URLBase = "http://User";

    public TestesIntegracaoUser()
    {
        _httpClient = new HttpClient();
    }
    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [TestCase("joao@gmail.com")]
    public async Task GetUserByEmail_ReturnsCorrectUser(string email)
    {
        // Arrange
        var userEmail = email;
        var expectedUser = new User { id = "1", username = "Tom", state = "0" };

        // Act
        var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
        response.EnsureSuccessStatusCode();

        var UserReal = await response.Content.ReadAsAsync();

        // Assert
        Assert.AreEqual(expectedUser.id, UserReal.id);
        Assert.AreEqual(expectedUser.username, UserReal.username);
        Assert.AreEqual(expectedUser.id, UsrReal.state);
    }

}
public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

[TestFixture]
public class TestesIntegracaoUser
{
    private readonly HttpClient _httpClient;
    private const string URLBase = "http://User";

    public TestesIntegracaoUser()
    {
        _httpClient = new HttpClient();
    }
    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [TestCase("joao@gmail.com")]
    public async Task GetUserByEmail_ReturnsCorrectUser(string email)
    {
        // Arrange
        var userEmail = email;
        var expectedUser = new User { id = "1", username = "Tom", state = "0" };

        // Act
        var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
        response.EnsureSuccessStatusCode();

        var UserReal = await response.Content.ReadAsAsync();

        // Assert
        Assert.AreEqual(expectedUser.id, UserReal.id);
        Assert.AreEqual(expectedUser.username, UserReal.username);
        Assert.AreEqual(expectedUser.id, UsrReal.state);
    }

}
public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

[TestFixture]
public class TestesIntegracaoUser
{
    private readonly HttpClient _httpClient;
    private const string URLBase = "http://User";

    public TestesIntegracaoUser()
    {
        _httpClient = new HttpClient();
    }
    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [TestCase("joao@gmail.com")]
    public async Task GetUserByEmail_ReturnsCorrectUser(string email)
    {
        // Arrange
        var userEmail = email;
        var expectedUser = new User { id = "1", username = "Tom", state = "0" };

        // Act
        var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
        response.EnsureSuccessStatusCode();

        var UserReal = await response.Content.ReadAsAsync();

        // Assert
        Assert.AreEqual(expectedUser.id, UserReal.id);
        Assert.AreEqual(expectedUser.username, UserReal.username);
        Assert.AreEqual(expectedUser.id, UsrReal.state);
    }

}
public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

[TestFixture]
public class TestesIntegracaoUser
{
    private readonly HttpClient _httpClient;
    private const string URLBase = "http://User";

    public TestesIntegracaoUser()
    {
        _httpClient = new HttpClient();
    }
    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [TestCase("joao@gmail.com")]
    public async Task GetUserByEmail_ReturnsCorrectUser(string email)
    {
        // Arrange
        var userEmail = email;
        var expectedUser = new User { id = "1", username = "Tom", state = "0" };

        // Act
        var response = await _httpClient.GetAsync($"{URLBase}/User/{userEmail}");
        response.EnsureSuccessStatusCode();

        var UserReal = await response.Content.ReadAsAsync();

        // Assert
        Assert.AreEqual(expectedUser.id, UserReal.id);
        Assert.AreEqual(expectedUser.username, UserReal.username);
        Assert.AreEqual(expectedUser.id, UsrReal.state);
    }

}
public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

Now the problem is that the ReadAsync() method can't read anything. But perhaps that is unavoidable if there is no real code or app to read anyting from??? I don't know, is it?

A

Angius•4/24/24, 6:41 PM

What is

ReadAsAsync()

ReadAsAsync()

ReadAsAsync()

ReadAsAsync()?

A

Angius•4/24/24, 6:41 PM

It's a hallucination of the LLM

A

Angius•4/24/24, 6:41 PM

It's not a method that exists

AAngius What is `ReadAsAsync()`?

G

GipperOP•4/24/24, 6:44 PM

It's not anything, it's a placeholder. I just left it as that...it's not meant to work because I assume that I would need to have the code or some form of the app to make that call and have it contain something.

G

GipperOP•4/24/24, 6:44 PM

This is essentially just meant to be a skeleton of the test which will be finalized once I have more to go on and to test

T

TeBeCo•4/24/24, 6:47 PM

    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

    [OneTimeTearDown]
    public void disposeHTTPClient() 
    {
        _httpClient.Dispose();
    }

T

TeBeCo•4/24/24, 6:47 PM

why do that in a TestTearDown ?

T

TeBeCo•4/24/24, 6:47 PM

beside noise, what's the necessity ?

A

Angius•4/24/24, 6:47 PM

No, you don't need anything from the project

A

Angius•4/24/24, 6:47 PM

You know what the API returns

TTeBeCo why do that in a TestTearDown ?

G

GipperOP•4/24/24, 6:47 PM

because NUnit was complaining

T

TeBeCo•4/24/24, 6:48 PM

i would shut that warning if the warning is stupid

T

TeBeCo•4/24/24, 6:48 PM

I would also probably not

new _httpClient

new _httpClient

new _httpClient

new _httpClient at class level to avoid state sharing and parallel testing

T

TeBeCo•4/24/24, 6:49 PM

which would ... solve that issue because teh warning would be gone

T

TeBeCo•4/24/24, 6:49 PM

I would create the client within the test

T

TeBeCo•4/24/24, 6:50 PM

also aren't you supposed to use

WebApplicationFactory

WebApplicationFactory

WebApplicationFactory

WebApplicationFactory and then get teh client from the thing directly ?

T

TeBeCo•4/24/24, 6:50 PM

public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

public class User
{
    public string id;
    public string username;
    public string state;
    public string email;
}

T

TeBeCo•4/24/24, 6:50 PM

please don't expose public field or even use lowercase on anything public

TTeBeCo also aren't you supposed to use `WebApplicationFactory` and then get teh client ...

G

GipperOP•4/24/24, 6:51 PM

Ooooh, I didn't understand that's what WebClientFactory was for

G

GipperOP•4/24/24, 6:51 PM

I do have that file in my proj

T

TeBeCo•4/24/24, 6:51 PM

no not

WebClientFactory

WebClientFactory

WebClientFactory

WebClientFactory

T

TeBeCo•4/24/24, 6:51 PM

WebApplicationFactory

WebApplicationFactory

WebApplicationFactory

WebApplicationFactory

T

TeBeCo•4/24/24, 6:51 PM

https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests?view=aspnetcore-8.0

Integration tests in ASP.NET Core

Learn how integration tests ensure that an app's components function correctly at the infrastructure level, including the database, file system, and network.

TTeBeCo `WebApplicationFactory`

G

GipperOP•4/24/24, 6:51 PM

yeah, mispell

T

TeBeCo•4/24/24, 6:51 PM

check that link

T

TeBeCo•4/24/24, 6:52 PM

T

TeBeCo•4/24/24, 6:52 PM

aside from the fact that they still have that class level thing that eventually could be hurted by parallel testing

T

TeBeCo•4/24/24, 6:52 PM

your code look like you're doing what that existing feature does

T

TeBeCo•4/24/24, 6:52 PM

read carrefully the pre requisite

T

TeBeCo•4/24/24, 6:53 PM

you will 100% need to either create a new project aside to split unit test and these integration test

T

TeBeCo•4/24/24, 6:53 PM

or edit your test csproj

T

TeBeCo•4/24/24, 6:53 PM

T

TeBeCo•4/24/24, 6:54 PM

i generally prefer xunit over nunit but that should work in both

✅ Please help me read this simple API endpoint documentation

Similar Threads

Similar Threads

Similar Threads