ProductsTests

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using FluentAssertions;
using NUnit.Framework;
using Shopping;

namespace ShoppingTests
{
    [TestFixture]
    public class Products_Should
    {
        [SetUp]
        public void Setup() => _products = new Products<string>();

        [Test]
        public void Start_Empty() => _products.Count.Should().Be(0);

        [Test]
        public void When_Adding_Product_Increases_Count()
        {
            _products.Add("Apple",15);
            _products.Count.Should().Be(1);
        }

        [Test]
        public void When_Initialize_Use_Object_Initializer()
        {
            var products = new Products<string>
            {
                {"Duck",12},
                {"Apple",5},
                {"Sword",25},
                {"McGuffin",999}
            };

            products.Count.Should().Be(4);
            products.GetPrice("McGuffin").Should().Be(999);
        }

        [Test]
        public void When_HasProduct_Returns_True()
        {
            _products.Add("Apple",15);
            _products.Has("Apple").Should().BeTrue();
        }

        [Test]
        public void When_GetPrice_Returns_Price()
        {
            _products.Add("Apple", 15);

            _products.GetPrice("Apple").Should().Be(15);
        }

        [Test]
        public void When_GetAffordable_Returns_Affordable_Products()
        {
            _products.Add("Turkey",19);
            _products.Add("Salmon", 15);
            _products.Add("Dog",25);

            var affordable = _products.GetAffordable(20);

            ContainsItems(affordable,"Salmon","Turkey");
        }

        [Test]
        public void When_GetTooExpensive_Returns_Unaffordable_Products()
        {
            _products.Add("Turkey",19);
            _products.Add("Salmon", 15);
            _products.Add("Dog",25);

            var affordable = _products.GetTooExpensive(20);

            ContainsItems(affordable,"Dog");
        }


        [Test]
        public void When_Foreach_Can_Iterate_Products()
        {
            _products.Add("Turkey",19);
            _products.Add("Salmon", 15);
            _products.Add("Dog",25);

            List<int> prices = new List<int>();
            foreach (var product in _products)
                prices.Add(product.Price);

            prices.Count.Should().Be(3);
            prices.Should().BeEquivalentTo(new List<int> {19, 15, 25});
        }

        [Test]
        public void When_CanAfford_Return_True_If_Has_Enough_Money()
        {
            _products.Add("Shield",100);
            _products.CanAfford("Shield", 200).Should().BeTrue();
        }

        [Test]
        public void When_Generic_Enumerating_ReturnsProducts()
        {
           _products.Add(DefaultProducts);

            var _enumerator = ((IEnumerable)_products).GetEnumerator();

            int count = 0;
            while (_enumerator.MoveNext()) count++;
            count.Should().Be(4);
        }

        IEnumerable<Products<string>.Product> DefaultProducts => new List<Products<string>.Product>
        {
            CreateProduct("Duck", 12),
            CreateProduct("Apple", 5),
            CreateProduct("Sword", 25),
            CreateProduct( "McGuffin",999)
        };

        Products<string>.Product CreateProduct(string name, int price) =>
            new Products<string>.Product {Item = name, Price = price};

        Products<string> _products;

        void ContainsItems(IEnumerable<Products<string>.Product> results, params string[] items) =>
            results.Select(x=>x.Item).Should().BeEquivalentTo(items);
    }
}