Unit Testing On OData Web API using .net

I am trying to implement Unit test cases on .Net OData Web API. However I am facing issue where I am passing a filter in the Http request URL to filter out the data but receiving same sort of mock data which I am sending. Need assistant what and where I am wrong.

Below is my code

here is the customer controller

public class CustomersController : ODataController
    {
        private readonly ICustomerRepository _repository;
        public CustomersController()
        {
            _repository = new CustomerRepository(new ODataSampleEntities());
        }

        public CustomersController(ICustomerRepository repository)
        {
            // this.genericRepository = repository;//new Repository<Customer>();
            _repository = repository;
        }
    
        [EnableQuery]
        public IQueryable<Customer> Get()
        {
            return _repository.GetAllCustomers();
        }
       
    }

Customer Model

public partial class Customer
{
        public int Id { get; set; }
        public string Name { get; set; }
        public string Country { get; set; }
        public string Address { get; set; }
}

Repository

    public interface ICustomerRepository
    {
        //IEnumerable<Customer> GetAllCustomers();
        IQueryable<Customer> GetAllCustomers();
    }

public class CustomerRepository: ICustomerRepository
    {
        private readonly ODataSampleEntities _context;

        public CustomerRepository(ODataSampleEntities context)
        {
            _context = context;
        }

        public virtual IQueryable<Customer> GetAllCustomers()
        {
            return _context.Customers;
        }
    }

Below is the Unit Test case code

public class CustomerControllerTests
    {
        [TestMethod]
        public void GetAllCustomers_ShouldReturnAllCustomers()
        {
            // Arrange
            var customers = new List<Customer>
            {
                new Customer { Id = 1, Name = "John", Country = "USA", Address = "USA" },
                new Customer { Id = 2, Name = "Sandesh", Country = "India", Address = "Goa India" }
            };
            var request = new HttpRequestMessage(HttpMethod.Get, "https://localhost:44395/Customers?$filter=Name eq 'Sandesh' & $top=1");

            HttpRouteCollection routes = new HttpRouteCollection();
            HttpConfiguration config = new HttpConfiguration(routes) { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
            var Customerbuilder = new ODataConventionModelBuilder();
            Customerbuilder.EntitySet<Customer>("Customer");
            var model = Customerbuilder.GetEdmModel();



            // attempting to register at least some non-OData HTTP route doesn't seem to help
            routes.MapHttpRoute("Default", "{controller}/{action}");
            config.MapODataServiceRoute("odata", "odata", model);
            config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
            config.EnableDependencyInjection();
            config.EnsureInitialized();

            request.SetConfiguration(config);
            ODataQueryContext context = new ODataQueryContext(
                model,
                typeof(Customer),
                new ODataPath(
                    new Microsoft.OData.UriParser.EntitySetSegment(
                        model.EntityContainer.FindEntitySet("Customer"))
                )
            );

            var mockRepository = new Mock<ICustomerRepository>();
            mockRepository.Setup(r => r.GetAllCustomers()).Returns(customers.AsQueryable());
            mockRepository.SetReturnsDefault<IEnumerable<Customer>>(customers.AsQueryable());

            // Create the controller
            var controller = new CustomersController(mockRepository.Object);
            controller.Request = request;

            var options = new ODataQueryOptions<Customer>(context, request);
            //var response = controller.Get(); //as ViewResult;

            // Act
            var result = controller.Get();

            // Assert
            Assert.IsNotNull(result);

             Assert.IsInstanceOfType(result, typeof(IEnumerable<Customer>));

            var contentResult = result;
            Assert.IsNotNull(contentResult);
            Assert.AreEqual(1, contentResult.Count());
            Assert.AreEqual("Sandesh", contentResult.First().Name);
        }
    }

Every time I run the unit test it gives me the same mock data even I pass a filter query via request Url. Please assist me to achieve and perform unit test case on my OData web api controller which will filter the data and will give it back response.

Slightly I modified the @Saeed Gholamzadeh suggested answer and it worked.

[TestMethod]
public void GetAllCustomers_ShouldReturnFilteredCustomers()
{
    // ... (existing code)

    var customers = new List<Customer>
    {
        new Customer { Id = 1, Name = "John", Country = "USA", Address = "USA" },
        new Customer { Id = 2, Name = "Sandesh", Country = "India", Address = "Goa India" }
    };

    // Modify the mock repository setup to consider the filter parameter
    mockRepository.Setup(r => r.GetAllCustomers())
                  .Returns(() => 
                  {
                          // Parse the filter and apply it to the customer list
                          var odataQuery = new ODataQueryOptions<Customer>(
                              new ODataQueryContext(model, typeof(Customer)), 
                              request
                          );
                          var filteredCustomers = odataQuery.ApplyTo(customers.AsQueryable());
                          return filteredCustomers as IQueryable<Customer>;
                  });

    // ... (existing code)
}

Here I removed a condition to check whether a filter is applied.

In your unit test code, you are setting up the mock repository to always return the same set of customers, regardless of the filter applied in the request URL. This is why you are getting the same mock data every time you run the unit test.

To simulate the filtering behavior in your unit test, you need to modify the mock repository setup to consider the filter parameter provided in the request URL and return the filtered data accordingly.

Here's how you can achieve that:

Modify your unit test method to include the filter parameter in the request URL:

[TestMethod]
public void GetAllCustomers_ShouldReturnFilteredCustomers()
{
    // ... (existing code)

    // Modify the request URL to include the filter parameter
    var request = new HttpRequestMessage(HttpMethod.Get, "https://localhost:44395/Customers?$filter=Name eq 'Sandesh'&$top=1");

    // ... (existing code)
}

Update the setup of your mock repository to return the filtered data:

[TestMethod]
public void GetAllCustomers_ShouldReturnFilteredCustomers()
{
    // ... (existing code)

    var customers = new List<Customer>
    {
        new Customer { Id = 1, Name = "John", Country = "USA", Address = "USA" },
        new Customer { Id = 2, Name = "Sandesh", Country = "India", Address = "Goa India" }
    };

    // Modify the mock repository setup to consider the filter parameter
    mockRepository.Setup(r => r.GetAllCustomers())
                  .Returns((string filter) => 
                  {
                      // Implement filtering based on the filter parameter
                      if (string.IsNullOrEmpty(filter))
                      {
                          return customers.AsQueryable(); // Return all customers if no filter
                      }
                      else
                      {
                          // Parse the filter and apply it to the customer list
                          var odataQuery = new ODataQueryOptions<Customer>(
                              new ODataQueryContext(model, typeof(Customer)), 
                              request
                          );
                          var filteredCustomers = odataQuery.ApplyTo(customers.AsQueryable());
                          return filteredCustomers as IQueryable<Customer>;
                      }
                  });

    // ... (existing code)
}

With this setup, the mock repository will now apply the filter specified in the request URL to the list of customers and return the filtered data accordingly when you call controller.Get(). This should enable you to properly test the filtering behavior of your OData Web API controller.