Electric Door

using FluentAssertions;
using NSubstitute;
using NUnit.Framework;
using SmartNetwork;

namespace SmartNetworkTests
{
    [TestFixture]
    public class ElectricDoor_Should
    {
        void Init()
        {
            PowerSource.ProvidingPower.Returns(true);
            _door.Attach(PowerSource);
        }

        [Test]
        public void Start_unlocked()
        {
            _door.TurnOn();
            _door.IsOpen.Should().BeFalse();
            _door.IsLocked.Should().BeFalse();
        }

        [Test]
        public void Start_without_power() => new ElectricDoor(_doorHandler).HasPower.Should().BeFalse();

        [Test]
        public void Not_function_when_not_powered()
        {
            PowerSource.ProvidingPower.Returns(false);

            _door.Handle(Message);
            _door.TurnOn();
            _door.Open();
            _door.ToggleOn();
            _door.ToggleOpen();
            _door.ToggleLocked();
            _door.Lock();
            _door.Unlock();

            _doorHandler.DidNotReceive().Handle(Message);
            _doorHandler.DidNotReceive().PoweredOn();
            _doorHandler.DidNotReceive().PoweredOff();
            _doorHandler.DidNotReceive().Opened();
            _doorHandler.DidNotReceive().Closed();
            _doorHandler.DidNotReceive().Locked();
            _doorHandler.DidNotReceive().UnLocked();
        }

        [Test]
        public void Handles_message()
        {
            _door.TurnOn();
            _door.Handle(Message);

            _doorHandler.Received().Handle(Message);
        }

        [Test]
        public void When_not_powered_toggling_lock_does_nothing()
        {
            _door.ToggleLocked();

            _door.IsLocked.Should().BeFalse();

            _doorHandler.DidNotReceive().Locked();
            _doorHandler.DidNotReceive().UnLocked();
            _doorHandler.DidNotReceive().Opened();
            _doorHandler.DidNotReceive().Closed();
        }

        [Test]
        public void When_powered_and_unlocked_toggling_lock_locks()
        {
            _door.TurnOn();
            _door.ToggleLocked();

            _doorHandler.Received().Locked();
        }

        [Test]
        public void When_powered_and_locked_toggling_lock_unlocks()
        {
            _door.TurnOn();
            _door.Lock();

            _door.ToggleLocked();

            _door.IsLocked.Should().BeFalse();

            _doorHandler.Received().Locked();
            _doorHandler.Received().UnLocked();

        }


        [Test]
        public void Can_be_locked()
        {
            _door.TurnOn();
            _door.Lock();

            _door.IsLocked.Should().BeTrue();
            _doorHandler.Received().Locked();
        }

        [Test]
        public void When_locked_wont_open()
        {
            _door.TurnOn();
            _door.Lock();

            _door.Open();
            _door.IsOpen.Should().BeFalse();

            _doorHandler.Received(1).TriedToOpen();
        }

        [Test]
        public void When_unlocked_can_open()
        {
            _door.TurnOn();
            _door.Lock();

            _door.Unlock();
            _door.Open();

            _door.IsOpen.Should().BeTrue();

            _doorHandler.Received(1).Opened();
            _doorHandler.Received(1).UnLocked();

            _doorHandler.DidNotReceive().TriedToOpen();
        }

        [Test]
        public void When_unlocked_unlocking_does_nothing()
        {
            _door.TurnOn();
            _door.Unlock();

            _doorHandler.DidNotReceive().UnLocked();
        }



        [Test]
        public void When_already_open_not_open_again()
        {
            _door.TurnOn();

            _door.Open();
            _door.Open();

            _doorHandler.Received(1).Opened();
        }

        [Test]
        public void When_on_and_toggled_turns_off()
        {
            _door.TurnOn();
            _door.ToggleOn();

            _door.IsOn.Should().BeFalse();
            _doorHandler.Received(1).PoweredOn();
            _doorHandler.Received(1).PoweredOff();
        }


        [Test]
        public void When_off_and_toggled_turns_on()
        {
            _door.ToggleOn();

            _door.IsOn.Should().BeTrue();
            _doorHandler.Received(1).PoweredOn();
            _doorHandler.DidNotReceive().PoweredOff();
        }

        [Test]
        public void When_not_on_cannot_open()
        {
            _door.Open();
            _door.IsOpen.Should().BeFalse();
            _doorHandler.DidNotReceive().Opened();
        }

        [Test]
        public void When_open_and_turned_off_cannot_close()
        {
            _door.TurnOn();
            _door.Open();

            _door.TurnOff();

            _door.Close();

            _door.IsOpen.Should().BeTrue();
        }

        [Test]
        public void When_loses_power_turns_off()
        {
            _door.TurnOn();

            var powerSource = _door.DetachPowerSource();

            _door.IsOn.Should().BeFalse();
            _door.HasPower.Should().BeFalse();

            powerSource.Should().Be(PowerSource);

            _doorHandler.Received(1).PoweredOff();
        }

        [Test]
        public void When_open_and_toggledOpen_closes()
        {
            _door.TurnOn();
            _door.Open();

            _door.ToggleOpen();

            _door.IsOpen.Should().BeFalse();
        }

        [Test]
        public void When_closed_and_toggledOpen_opens()
        {
            _door.TurnOn();
            _door.ToggleOpen();

            _door.IsOpen.Should().BeTrue();
        }

        [Test]
        public void When_closed_and_closing_does_nothing()
        {
            _door.TurnOn();

            _door.Close();

            _doorHandler.DidNotReceive().Closed();

        }

        [Test]
        public void When_not_locked_and_powerOn_Opens()
        {
            _door.TurnOn();

            _door.Open();

            _door.IsOpen.Should().BeTrue();
            _doorHandler.Received().Opened();
        }

        [Test]
        public void When_open_cannot_lock()
        {
            _door.TurnOn();
            _door.Open();

            _door.Lock();

            _door.IsLocked.Should().BeFalse();
            _doorHandler.DidNotReceive().Locked();
        }

        [Test]
        public void When_locked_and_turned_off_cannot_unlock()
        {
            _door.TurnOn();
            _door.Lock();

            _door.TurnOff();

            _door.Unlock();

            _door.IsLocked.Should().BeTrue();
            _doorHandler.DidNotReceive().UnLocked();
        }

        #region Plumbing

        [SetUp]
        public void Setup()
        {
            PowerSource = Substitute.For<PowerSource>();
            _doorHandler = Substitute.For<DoorHandler>();
            _door = new ElectricDoor(_doorHandler);
            Init();
        }

        DoorHandler _doorHandler;
        const string Message = "MESSAGE";
        ElectricDoor _door;
        PowerSource PowerSource;

        #endregion
    }
}