using System;
using System.Collections.Generic;
using NUnit.Framework;

namespace Chernobyl.Creation.Collections
{
    [TestFixture, Description("Tests for the BuilderEnumerable<T> type.")]
    public class BuilderEnumerableTests : EnumerationTests<IBuilder<int>>
    {
        public BuilderEnumerableTests() : base(false)
        {}

        [Test, Description("Ensures that BuilderEnumerable<T>(IEnumerable<IBuilder<T>>) " +
            "throws an exception when its first argument is null.")]
        public void ConstructorArgumentNullExceptionFirstArgument()
        {
            Assert.Throws<ArgumentNullException>(() => CreateBuilderEnumerable(null));
        }

        [Test, Description("Ensures that BuilderEnumerable<T>.Created is raised " +
            "when an IBuilder<T> contained by BuilderEnumerable<T> raises its own " +
            "IBuilder<T>.Created event.")]
        public void CreatedRaised()
        {
            IFactory<int> factory = new DefaultConstructorFactory<int>();
            BuilderEnumerable<IBuilder<int>, int> test = CreateBuilderEnumerable(new IBuilder<int>[] { factory });
            test.Created += (sender, e) => Assert.Pass("IBuilder<T>.Created event was raised.");

            factory.Create();

            Assert.Fail("IBuilder<T>.Created event was not raised.");
        }

        /// <summary>
        /// Creates the instances that are to be tested. This method should be
        /// overridden by any set of tests that are testing types derived from
        /// <see cref="BuilderEnumerable{TFactory, TItem}"/>. This method must
        /// return a new instance every time it is called.
        /// </summary>
        /// <param name="builders">The <see cref="IBuilder{T}"/> instances to
        /// be taken by the types constructor.</param>
        /// <returns>The instance that is to be tested.</returns>
        protected virtual BuilderEnumerable<IBuilder<int>, int> CreateBuilderEnumerable(IEnumerable<IBuilder<int>> builders)
        {
            return new BuilderEnumerable<IBuilder<int>, int>(builders);
        }

        protected override IEnumerable<IBuilder<int>> CreateSingleItemEnumerable()
        {
            return CreateBuilderEnumerable( new[] { new DefaultConstructorFactory<int>() } );
        }

        protected override IEnumerable<IBuilder<int>> CreateManyItemEnumerable()
        {
            BuilderEnumerable<IBuilder<int>, int> enumerable = CreateBuilderEnumerable(new[]
                                       {
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>()
                                       });
            return enumerable;
        }
    }
}