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'

​

​

​

*/

​