[Fork] How to use NUnit in .NETFiddle | C# Online Compiler

[Fork] How to use NUnit in .NETFiddle by awong5@slb.com

using System;
using NUnit.Framework;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using NSubstitute;
using System.Linq;

namespace LS{
/////////////
// Controller
/////////////
	
public class TagsController : ControllerBase
{
    private readonly Demo1DbContext _context;
    private readonly ITagsService tagsService;

    public TagsController(Demo1DbContext context,
       ITagsService tagsService)
    {
        _context = context;
        this.tagsService = tagsService;
    }

    [HttpGet]
    public async Task<ActionResult<ICollection<Tag>>> GetTags()
    {
        return Ok(await tagsService.GetTags());
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Tag>> GetTag(int id)
    {
        var Tag = await _context.Tags.FindAsync(id);
        return Tag == null ? NotFound() : Ok(Tag);
    }

    [HttpPost]
    public async Task<ActionResult<Tag>> CreateTag(Tag Tag)
    {
        _context.Tags.Add(Tag);

        await _context.SaveChangesAsync();
        return CreatedAtAction(nameof(GetTag), new { id = Tag.Id }, Tag);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateTag(int id, Tag Tag)
    {
        if (id != Tag.Id) return BadRequest();

        _context.Entry(Tag).State = EntityState.Modified;
        await _context.SaveChangesAsync();

        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteTag(int id)
    {
        var Tag = await _context.Tags.FindAsync(id);
        if (Tag == null) return NotFound();

        _context.Tags.Remove(Tag);
        await _context.SaveChangesAsync();

        return NoContent();
    }
}

/////////////
// Service
/////////////

public interface ITagsService
{
    Task<Tag> CreateTag(Tag tag);
    Task<Tag> UpdateTag(string TagId, Tag tag);
    Task DeleteTag(string id);
    Task<Tag?> GetTag(string tagId);

    Task<ICollection<Tag>> GetTags();
    Task<List<ExistResponse>> CheckNamesExist(List<string> names);
}

public class TagsService : ITagsService
{
    private readonly Demo1DbContext _context;

    public TagsService(Demo1DbContext context)
    {
        this._context = context;
    }

    public async Task<Tag> CreateTag(Tag tag)
    {
        throw new NotImplementedException();
    }

    public async Task DeleteTag(string id)
    {
        throw new NotImplementedException();
    }

    public async Task<Tag?> GetTag(string tagId)
    {
        throw new NotImplementedException();
    }

    public async Task<ICollection<Tag>> GetTags()
    {
        return await _context.Tags.Select(t => new Tag
        {
            Id = t.Id,
            Name = t.Name,
            IsUsed = t.IsUsed
        }).ToListAsync();
    }

    public async Task<List<ExistResponse>> CheckNamesExist(List<string> names)
    {
        throw new NotImplementedException();
    }

    public async Task<Tag> UpdateTag(string tagId, Tag tag)
    {
        throw new NotImplementedException();
    }
}

////////
// Model
////////
public class Tag
{
    public int? Id { get; set; }
    public string? Name { get; set; }
    public bool IsUsed { get; set; }
    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
}

public class ExistResponse
{
    public string Name { get; set; } = string.Empty;
    public bool Exists { get; set; } = false;
}
	
public class Demo1DbContext : DbContext
{
    public Demo1DbContext(DbContextOptions<Demo1DbContext> options)
        : base(options) { }

    public DbSet<Tag> Tags { get; set; } = null!;
}

///////
// TEST
///////
public class TagsControllerTests
{
    private DbContextOptions<Demo1DbContext> _options;
    private Demo1DbContext _context;
    private ITagsService _mockTagsService;
    private TagsController _tagsController;

    [SetUp]
    public void Setup()
    {
        // Initialize DbContextOptions with in-memory database provider
        _options = new DbContextOptionsBuilder<Demo1DbContext>()
            .UseInMemoryDatabase(databaseName: "test_database")
            .Options;

        _context = new Demo1DbContext(_options);

        //// Ensure database is cleared before seeding
        _context.Database.EnsureDeleted();
        _context.Database.EnsureCreated();

        _context.Tags.AddRange(new[]
        {
                new Tag { Id = 1, Name = "Tag1" },
                new Tag { Id = 2, Name = "Tag2" },
                new Tag { Id = 3, Name = "Tag3" }
            });
        _context.SaveChanges();

        //_tagsService = new TagsService(_context);
        _mockTagsService = Substitute.For<ITagsService>();
        _tagsController = new TagsController(_context, _mockTagsService);
    }

    [TearDown]
    public async Task Teardown()
    {
        await _context.DisposeAsync();
    }

    [Test]
    public async Task GetTags_Valid_ReturnTag()
    {
        var expectedTagResponse = new Tag
        {
            Id = 1,
            Name = "tag-name-1",
            IsUsed = true
        };
        _mockTagsService.GetTags().Returns(new List<Tag> { expectedTagResponse });

        var tagsResult = await _tagsController.GetTags();


        var tagsResultObject = tagsResult.Result as ObjectResult;
        Assert.That(tagsResultObject, Is.Not.Null);
        ICollection<Tag>? tags = tagsResultObject.Value as ICollection<Tag>;
        Assert.That(tags, Is.Not.Null);
        var tagsList = tags.ToList();

        Assert.Multiple(() =>
        {
            Assert.That(tags, Is.Not.Null);
            Assert.That(tags, Has.Count.EqualTo(1));
            Assert.That(tagsList[0].Id, Is.EqualTo(1));
            Assert.That(tagsList[0].Name, Is.EqualTo("tag-name-1"));
            Assert.That(tagsList[0].IsUsed, Is.EqualTo(true));
        });
    }
}

public class TagServiceTests
{
    private DbContextOptions<Demo1DbContext> _options;
    private Demo1DbContext _context;
    private TagsService _tagsService;

    [SetUp]
    public void Setup()
    {
        // Initialize DbContextOptions with in-memory database provider
        _options = new DbContextOptionsBuilder<Demo1DbContext>()
            .UseInMemoryDatabase(databaseName: "test_database")
            .Options;

        _context = new Demo1DbContext(_options);

        //// Ensure database is cleared before seeding
        _context.Database.EnsureDeleted();
        _context.Database.EnsureCreated();

        _context.Tags.AddRange(new[]
        {
                new Tag { Id = 1, Name = "Tag1" },
                new Tag { Id = 2, Name = "Tag2" },
                new Tag { Id = 3, Name = "Tag3" }
            });
        _context.SaveChanges();

        _tagsService = new TagsService(_context);
    }

    [TearDown]
    public async Task Teardown()
    {
        await _context.DisposeAsync();
    }

    [Test]
    public async Task GetTags_ReturnsMatchingTags()
    {
        // Act
        var result = (await _tagsService.GetTags()).ToList();

        // Assert
        Assert.That(result, Has.Count.EqualTo(3));
    }


    [Test]
    public async Task GeneralTagTest_ReturnsMatchingTags()
    {
        // Act
        var result = (await _tagsService.GetTags()).ToList();

        // Assert
        Assert.That(result, Has.Count.EqualTo(3));
    }
}

///////
// Main
///////	
public class Program
{
	public static void Main() 
	{
		var x = new NUnitLite.AutoRun().Execute(new string[]{"--test:LS.TagsControllerTests", "--noc"});
		Console.WriteLine("");
		Console.WriteLine("----------------------------------------------");
		Console.WriteLine("TagsControllerTests");
		Console.WriteLine(x==0?"All Test Passed... :¬)": string.Format("{0} tests failed... :¬(", x));
		Console.WriteLine("----------------------------------------------");

		var y = new NUnitLite.AutoRun().Execute(new string[]{"--test:LS.TagServiceTests", "--noc"});
		Console.WriteLine("TagsServiceTests");
		Console.WriteLine("----------------------------------------------");
		Console.WriteLine("");
		Console.WriteLine(y==0?"All Test Passed... :¬)": string.Format("{0} tests failed... :¬(", y));
		Console.WriteLine("----------------------------------------------");
	}
}

}




/*

----------------------------------------------------------------------------------------------------
#Exercise 1: Refactoring 

Objective: Transfer all controller logic to the service layer to eliminate the dependency on DB Context.

1a) Move Business Logic to Service: Create methods in ITagsService that encapsulate the business logic for retrieving, creating, updating, and deleting tags. [Done] 

	[TODO] Implement these methods in a class that implements ITagsService.

1b) Modify Controller to Use Service: Inject ITagsService into TagsController instead of Demo1DbContext. [Done] 
	
	[TODO] Update each action in TagsController to call the corresponding method from ITagsService.

see 'GetTags' as an example:

----------------------------------------------------------------------------------------------------
#Exercise 2: Requirement : Users are not required to provide the Id and CreatedDate.

To update the Tag class by changing the Id property from int to string and adjusting the necessary logic and tests, follow these steps:

2a - (how to make surethe Users are not required to provide the Id and CreatedDate. ??)
2b - Adjust CreateTag Method in TagsService: Implement logic to generate a new GUID and assign it to the Id property. 
2c - Update Dependencies and TagServiceTests: Resolve all compilation errors resulting from the changes.

----------------------------------------------------------------------------------------------------
#Exercise 3: New Enhancement :- [Add new Method 'Exists']

Implementation in TagsService:
Method Name: Exists(List<string> ids)
Functionality: Queries the database to check the existence of each Id provided in the list.
Returns: A list of ExistResponse objects, where each object contains the Id and a boolean IsExists indicating whether the Id exists (true) or not (false) in the database.

 3a - in TagService, add the method with the 

    public async Task<List<ExistResponse>> CheckNamesExist(List<string> names)
    {
    }



 3b - in TagServiceTests, Add the following test method and ensure its successful execution.


    [Test]
    public async Task CheckNamesExist_Returns()
    {
        // Act
        var result = (await _tagsService.CheckNamesExist(["Tag1", "Tag2", "Tag3", "Tag4"])).ToList();

        // Assert
        Assert.That(result, Has.Count.EqualTo(4));
        Assert.That(result[0].Name, Is.EqualTo("Tag1"));
        Assert.That(result[0].Exists, Is.EqualTo(true));
        Assert.That(result[1].Name, Is.EqualTo("Tag2"));
        Assert.That(result[1].Exists, Is.EqualTo(true));
        Assert.That(result[2].Name, Is.EqualTo("Tag3"));
        Assert.That(result[2].Exists, Is.EqualTo(true));
        Assert.That(result[3].Name, Is.EqualTo("Tag4"));
        Assert.That(result[3].Exists, Is.EqualTo(false));
    }



----------------------------------------------------------------------------------------------------
#Exercise 4: Implement Workflow Unit-Test for CRUD Operations in TagsService

Objective: Verify the end-to-end CRUD (Create, Read, Update, Delete) workflow for tags in TagsService.

Steps:
a. Create a New Tag	: Verify that the response includes an ID (*) that is neither null nor an empty string.
b. Retrieve Tag by ID	: Get the tag using the ID obtained from the create operation and verify that the name matches the expected value.
c. Update Tag		: Update the tag using the returned ID, then retrieve it and verify that the name matches the updated expected value.
d. Delete Tag		: Delete the tag using the returned ID, then verify that attempting to retrieve the tag results in a TagNotFoundException.


----------------------------------------------------------------------------------------------------
#Exercise 5: New Enhancement :- [goal : return 2 different types of validation errors.. Implement Special Error Handling in Delete]

5a: Update TagsService with Special Error Handling : Modify the TagsService to handle TagNotFoundException and TagNameWithValueMasterCannotBeDeletedException during tag deletion

	TagNotFoundException: Handle this exception when attempting to delete a tag that does not exist.
	TagNameWithValueMasterCannotBeDeletedException: Implement handling for cases where deletion of a tag named "Master" with a specific value is attempted.

5b: Added tests in TagServiceTests and TagsControllerTests to verify the error handling scenarios using appropriate assertions and mocks.
	- Add Tests for Error Handling in Service Tests (TagServiceTests)
	-Use NSubstitute to mock ITagsService and verify error handling in TagsController (TagsControllerTests with Mock Approach)  similiar to the existing test 'TagsControllerTests.GetTags_Valid_ReturnTag'



*/

​x
 
using System;
using NUnit.Framework;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using NSubstitute;
using System.Linq;
​
namespace LS{
/////////////
// Controller
/////////////
    
public class TagsController : ControllerBase
{
    private readonly Demo1DbContext _context;
    private readonly ITagsService tagsService;
​
    public TagsController(Demo1DbContext context,
       ITagsService tagsService)
    {
        _context = context;
        this.tagsService = tagsService;
    }
​
    [HttpGet]
    public async Task<ActionResult<ICollection<Tag>>> GetTags()
    {
        return Ok(await tagsService.GetTags());
    }
​
    [HttpGet("{id}")]
    public async Task<ActionResult<Tag>> GetTag(int id)
    {
        var Tag = await _context.Tags.FindAsync(id);
        return Tag == null ? NotFound() : Ok(Tag);
    }
​
    [HttpPost]
    public async Task<ActionResult<Tag>> CreateTag(Tag Tag)
    {
        _context.Tags.Add(Tag);
​
        await _context.SaveChangesAsync();
        return CreatedAtAction(nameof(GetTag), new { id = Tag.Id }, Tag);
    }
​
    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateTag(int id, Tag Tag)
    {
        if (id != Tag.Id) return BadRequest();
​
        _context.Entry(Tag).State = EntityState.Modified;
        await _context.SaveChangesAsync();
​
        return NoContent();
    }
​
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteTag(int id)
    {
        var Tag = await _context.Tags.FindAsync(id);
        if (Tag == null) return NotFound();
​
        _context.Tags.Remove(Tag);
        await _context.SaveChangesAsync();
​
        return NoContent();
    }
}
​
/////////////
// Service
/////////////
​
public interface ITagsService
{
    Task<Tag> CreateTag(Tag tag);
    Task<Tag> UpdateTag(string TagId, Tag tag);
    Task DeleteTag(string id);
    Task<Tag?> GetTag(string tagId);
​
    Task<ICollection<Tag>> GetTags();
    Task<List<ExistResponse>> CheckNamesExist(List<string> names);
}
​
public class TagsService : ITagsService
{
    private readonly Demo1DbContext _context;
​
    public TagsService(Demo1DbContext context)
    {
        this._context = context;
    }
​
    public async Task<Tag> CreateTag(Tag tag)
    {
        throw new NotImplementedException();
    }
​
    public async Task DeleteTag(string id)
    {
        throw new NotImplementedException();
    }
​
    public async Task<Tag?> GetTag(string tagId)
    {
        throw new NotImplementedException();
    }
​
    public async Task<ICollection<Tag>> GetTags()
    {
        return await _context.Tags.Select(t => new Tag
        {
            Id = t.Id,
            Name = t.Name,
            IsUsed = t.IsUsed
        }).ToListAsync();
    }
​
    public async Task<List<ExistResponse>> CheckNamesExist(List<string> names)
    {
        throw new NotImplementedException();
    }
​
    public async Task<Tag> UpdateTag(string tagId, Tag tag)
    {
        throw new NotImplementedException();
    }
}
​
////////
// Model
////////
public class Tag
{
    public int? Id { get; set; }
    public string? Name { get; set; }
    public bool IsUsed { get; set; }
    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
}
​
public class ExistResponse
{
    public string Name { get; set; } = string.Empty;
    public bool Exists { get; set; } = false;
}
    
public class Demo1DbContext : DbContext
{
    public Demo1DbContext(DbContextOptions<Demo1DbContext> options)
        : base(options) { }
​
    public DbSet<Tag> Tags { get; set; } = null!;
}
​
///////
// TEST
///////
public class TagsControllerTests
{
    private DbContextOptions<Demo1DbContext> _options;
    private Demo1DbContext _context;
    private ITagsService _mockTagsService;
    private TagsController _tagsController;
​
    [SetUp]
    public void Setup()
    {
        // Initialize DbContextOptions with in-memory database provider
        _options = new DbContextOptionsBuilder<Demo1DbContext>()
            .UseInMemoryDatabase(databaseName: "test_database")
            .Options;
​
        _context = new Demo1DbContext(_options);
​
        //// Ensure database is cleared before seeding
        _context.Database.EnsureDeleted();
        _context.Database.EnsureCreated();
​
        _context.Tags.AddRange(new[]
        {
                new Tag { Id = 1, Name = "Tag1" },
                new Tag { Id = 2, Name = "Tag2" },
                new Tag { Id = 3, Name = "Tag3" }
            });
        _context.SaveChanges();
​
        //_tagsService = new TagsService(_context);
        _mockTagsService = Substitute.For<ITagsService>();
        _tagsController = new TagsController(_context, _mockTagsService);
    }
​
    [TearDown]
    public async Task Teardown()
    {
        await _context.DisposeAsync();
    }
​
    [Test]
    public async Task GetTags_Valid_ReturnTag()
    {
        var expectedTagResponse = new Tag
        {
            Id = 1,
            Name = "tag-name-1",
            IsUsed = true
        };
        _mockTagsService.GetTags().Returns(new List<Tag> { expectedTagResponse });
​
        var tagsResult = await _tagsController.GetTags();
​
​
        var tagsResultObject = tagsResult.Result as ObjectResult;
        Assert.That(tagsResultObject, Is.Not.Null);
        ICollection<Tag>? tags = tagsResultObject.Value as ICollection<Tag>;
        Assert.That(tags, Is.Not.Null);
        var tagsList = tags.ToList();
​
        Assert.Multiple(() =>
        {
            Assert.That(tags, Is.Not.Null);
            Assert.That(tags, Has.Count.EqualTo(1));
            Assert.That(tagsList[0].Id, Is.EqualTo(1));
            Assert.That(tagsList[0].Name, Is.EqualTo("tag-name-1"));
            Assert.That(tagsList[0].IsUsed, Is.EqualTo(true));
        });
    }
}
​
public class TagServiceTests
{
    private DbContextOptions<Demo1DbContext> _options;
    private Demo1DbContext _context;
    private TagsService _tagsService;
​
    [SetUp]
    public void Setup()
    {
        // Initialize DbContextOptions with in-memory database provider
        _options = new DbContextOptionsBuilder<Demo1DbContext>()
            .UseInMemoryDatabase(databaseName: "test_database")
            .Options;
​
        _context = new Demo1DbContext(_options);
​
        //// Ensure database is cleared before seeding
        _context.Database.EnsureDeleted();
        _context.Database.EnsureCreated();
​
        _context.Tags.AddRange(new[]
        {
                new Tag { Id = 1, Name = "Tag1" },
                new Tag { Id = 2, Name = "Tag2" },
                new Tag { Id = 3, Name = "Tag3" }
            });
        _context.SaveChanges();
​
        _tagsService = new TagsService(_context);
    }
​
    [TearDown]
    public async Task Teardown()
    {
        await _context.DisposeAsync();
    }
​
    [Test]
    public async Task GetTags_ReturnsMatchingTags()
    {
        // Act
        var result = (await _tagsService.GetTags()).ToList();
​
        // Assert
        Assert.That(result, Has.Count.EqualTo(3));
    }
​
​
    [Test]
    public async Task GeneralTagTest_ReturnsMatchingTags()
    {
        // Act
        var result = (await _tagsService.GetTags()).ToList();
​
        // Assert
        Assert.That(result, Has.Count.EqualTo(3));
    }
}
​
///////
// Main
/////// 
public class Program
{
    public static void Main() 
    {
        var x = new NUnitLite.AutoRun().Execute(new string[]{"--test:LS.TagsControllerTests", "--noc"});
        Console.WriteLine("");
        Console.WriteLine("----------------------------------------------");
        Console.WriteLine("TagsControllerTests");
        Console.WriteLine(x==0?"All Test Passed... :¬)": string.Format("{0} tests failed... :¬(", x));
        Console.WriteLine("----------------------------------------------");
​
        var y = new NUnitLite.AutoRun().Execute(new string[]{"--test:LS.TagServiceTests", "--noc"});
        Console.WriteLine("TagsServiceTests");
        Console.WriteLine("----------------------------------------------");
        Console.WriteLine("");
        Console.WriteLine(y==0?"All Test Passed... :¬)": string.Format("{0} tests failed... :¬(", y));
        Console.WriteLine("----------------------------------------------");
    }
}
​
}
​
​
​
​
/*
​
----------------------------------------------------------------------------------------------------
#Exercise 1: Refactoring 
​
Objective: Transfer all controller logic to the service layer to eliminate the dependency on DB Context.
​
1a) Move Business Logic to Service: Create methods in ITagsService that encapsulate the business logic for retrieving, creating, updating, and deleting tags. [Done] 
​
    [TODO] Implement these methods in a class that implements ITagsService.
​
1b) Modify Controller to Use Service: Inject ITagsService into TagsController instead of Demo1DbContext. [Done] 
    
    [TODO] Update each action in TagsController to call the corresponding method from ITagsService.
​
see 'GetTags' as an example:
​
----------------------------------------------------------------------------------------------------
#Exercise 2: Requirement : Users are not required to provide the Id and CreatedDate.
​
To update the Tag class by changing the Id property from int to string and adjusting the necessary logic and tests, follow these steps:
​
2a - (how to make surethe Users are not required to provide the Id and CreatedDate. ??)
2b - Adjust CreateTag Method in TagsService: Implement logic to generate a new GUID and assign it to the Id property. 
2c - Update Dependencies and TagServiceTests: Resolve all compilation errors resulting from the changes.
​
----------------------------------------------------------------------------------------------------
#Exercise 3: New Enhancement :- [Add new Method 'Exists']
​
Implementation in TagsService:
Method Name: Exists(List<string> ids)
Functionality: Queries the database to check the existence of each Id provided in the list.
Returns: A list of ExistResponse objects, where each object contains the Id and a boolean IsExists indicating whether the Id exists (true) or not (false) in the database.
​
 3a - in TagService, add the method with the 
​
    public async Task<List<ExistResponse>> CheckNamesExist(List<string> names)
    {
    }
​
​
​
 3b - in TagServiceTests, Add the following test method and ensure its successful execution.
​
​
    [Test]
    public async Task CheckNamesExist_Returns()
    {
        // Act
        var result = (await _tagsService.CheckNamesExist(["Tag1", "Tag2", "Tag3", "Tag4"])).ToList();
​
        // Assert
        Assert.That(result, Has.Count.EqualTo(4));
        Assert.That(result[0].Name, Is.EqualTo("Tag1"));
        Assert.That(result[0].Exists, Is.EqualTo(true));
        Assert.That(result[1].Name, Is.EqualTo("Tag2"));
        Assert.That(result[1].Exists, Is.EqualTo(true));
        Assert.That(result[2].Name, Is.EqualTo("Tag3"));
        Assert.That(result[2].Exists, Is.EqualTo(true));
        Assert.That(result[3].Name, Is.EqualTo("Tag4"));
        Assert.That(result[3].Exists, Is.EqualTo(false));
    }
​
​
​
----------------------------------------------------------------------------------------------------
#Exercise 4: Implement Workflow Unit-Test for CRUD Operations in TagsService
​
Objective: Verify the end-to-end CRUD (Create, Read, Update, Delete) workflow for tags in TagsService.
​
Steps:
a. Create a New Tag : Verify that the response includes an ID (*) that is neither null nor an empty string.
b. Retrieve Tag by ID   : Get the tag using the ID obtained from the create operation and verify that the name matches the expected value.
c. Update Tag       : Update the tag using the returned ID, then retrieve it and verify that the name matches the updated expected value.
d. Delete Tag       : Delete the tag using the returned ID, then verify that attempting to retrieve the tag results in a TagNotFoundException.
​
​
----------------------------------------------------------------------------------------------------
#Exercise 5: New Enhancement :- [goal : return 2 different types of validation errors.. Implement Special Error Handling in Delete]
​
5a: Update TagsService with Special Error Handling : Modify the TagsService to handle TagNotFoundException and TagNameWithValueMasterCannotBeDeletedException during tag deletion
​
    TagNotFoundException: Handle this exception when attempting to delete a tag that does not exist.
    TagNameWithValueMasterCannotBeDeletedException: Implement handling for cases where deletion of a tag named "Master" with a specific value is attempted.
​
5b: Added tests in TagServiceTests and TagsControllerTests to verify the error handling scenarios using appropriate assertions and mocks.
    - Add Tests for Error Handling in Service Tests (TagServiceTests)
    -Use NSubstitute to mock ITagsService and verify error handling in TagsController (TagsControllerTests with Mock Approach)  similiar to the existing test 'TagsControllerTests.GetTags_Valid_ReturnTag'
​
​
​
*/
​

Stack overflow.
Repeat 4805 times:
--------------------------------
   at Unity.Builder.BuilderContext.Resolve(System.Type, System.String, Unity.Registration.InternalRegistration)
   at Unity.Builder.BuilderContext.Resolve(System.Type, System.String)
   at Unity.Builder.BuilderContext.Resolve(System.Reflection.ParameterInfo, System.Object)
   at Unity.Processors.ParametersProcessor`1+<>c__DisplayClass7_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<CreateParameterResolvers>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.ConstructorProcessor+<>c__DisplayClass16_0.<GetResolverDelegate>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.UnityContainer+<>c__DisplayClass113_0.<OptimizingFactory>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Strategies.BuildPlanStrategy.PreBuildUp(Unity.Builder.BuilderContext ByRef)
   at Unity.UnityContainer+<>c.<.ctor>b__73_2(Unity.Strategies.BuilderStrategy[], Unity.Builder.BuilderContext ByRef)
--------------------------------
   at Unity.Builder.BuilderContext.Resolve(System.Type, System.String, Unity.Registration.InternalRegistration)
   at Unity.Builder.BuilderContext.Resolve(System.Type, System.String)
   at Unity.Builder.BuilderContext.Resolve(System.Reflection.ParameterInfo, System.Object)
   at Unity.Processors.ParametersProcessor`1+<>c__DisplayClass7_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<CreateParameterResolvers>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.ConstructorProcessor+<>c__DisplayClass16_0.<GetResolverDelegate>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Processors.MemberProcessor`2+<>c__DisplayClass8_0[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]].<GetResolver>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.UnityContainer+<>c__DisplayClass113_0.<OptimizingFactory>b__0(Unity.Builder.BuilderContext ByRef)
   at Unity.Strategies.BuildPlanStrategy.PreBuildUp(Unity.Builder.BuilderContext ByRef)
   at Unity.UnityContainer+<>c.<.ctor>b__73_1(Unity.Builder.BuilderContext ByRef)
   at Unity.UnityContainer.Unity.IUnityContainer.Resolve(System.Type, System.String, Unity.Resolution.ResolverOverride[])
   at Unity.UnityContainerExtensions.Resolve[[System.__Canon, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]](Unity.IUnityContainer, Unity.Resolution.ResolverOverride[])
   at Program.Main()
Command terminated by signal 6

Last Run:	2:19:13 pm
Compile:	0.033s
Execute:	0.22s
Memory:	8.45Mb
CPU:	0.253s

View IL Code