DP44/Common/DTS.Common.Tests/FilterClassShould.cs

using DTS.Common.Classes.Sensors;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.Sensors;
using NSubstitute;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;


namespace DTS.Common.Classes.Sensors
{
    [TestFixture]
    class FilterClassShould
    {
        List<ISoftwareFilter> softwareFilters = null;

        [SetUp]
        public void SetUp()
        {
            //Arrange 
            ISoftwareFilter softwareFilter0 = Substitute.For<ISoftwareFilter>();
            softwareFilter0.ISOCode.Returns('0');
            softwareFilter0.Frequency.Returns(0.0);

            ISoftwareFilter softwareFilterP = Substitute.For<ISoftwareFilter>();
            softwareFilterP.ISOCode.Returns('P');
            softwareFilterP.Frequency.Returns(0.0);


            ISoftwareFilter softwareFilterQ = Substitute.For<ISoftwareFilter>();
            softwareFilterQ.ISOCode.Returns('Q');
            softwareFilterQ.Frequency.Returns(17.0);


            ISoftwareFilter softwareFilterD = Substitute.For<ISoftwareFilter>();
            softwareFilterD.ISOCode.Returns('D');
            softwareFilterD.Frequency.Returns(100.00);


            ISoftwareFilter softwareFilterC = Substitute.For<ISoftwareFilter>();
            softwareFilterC.ISOCode.Returns('C');
            softwareFilterC.Frequency.Returns(300.0);


            ISoftwareFilter softwareFilterB = Substitute.For<ISoftwareFilter>();
            softwareFilterB.ISOCode.Returns('B');
            softwareFilterB.Frequency.Returns(1000.0);


            ISoftwareFilter softwareFilterA = Substitute.For<ISoftwareFilter>();
            softwareFilterA.ISOCode.Returns('A');
            softwareFilterA.Frequency.Returns(1650.0);


            ISoftwareFilter softwareFilterSFirst = Substitute.For<ISoftwareFilter>();
            softwareFilterSFirst.ISOCode.Returns('S');
            softwareFilterSFirst.Frequency.Returns(1700.0);


            ISoftwareFilter softwareFilterSSecond = Substitute.For<ISoftwareFilter>();
            softwareFilterSSecond.ISOCode.Returns('S');
            softwareFilterSSecond.Frequency.Returns(1750.0);

            softwareFilters = new List<ISoftwareFilter>();
            softwareFilters.Add(softwareFilter0);
            softwareFilters.Add(softwareFilterP);
            softwareFilters.Add(softwareFilterQ);
            softwareFilters.Add(softwareFilterD);
            softwareFilters.Add(softwareFilterC);
            softwareFilters.Add(softwareFilterB);
            softwareFilters.Add(softwareFilterA);
            softwareFilters.Add(softwareFilterSFirst);
            softwareFilters.Add(softwareFilterSSecond);
        }

        [TearDown]
        public void TearDown()
        {
            softwareFilters = null;
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenNull()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString(null);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenEmpty()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustom()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("1700");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
            Assert.That(result.Frequency, Is.EqualTo(1700));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustomHz()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("1700Hz");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
            Assert.That(result.Frequency, Is.EqualTo(1700));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC10_When10()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("10");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
            Assert.That(result.Frequency, Is.EqualTo(17));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC10_WhenCFC10()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("CFC 10");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
            Assert.That(result.Frequency, Is.EqualTo(17));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC1000_When1000()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("1000");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
            Assert.That(result.Frequency, Is.EqualTo(1650));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC1000_WhenCFC1000()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("CFC 1000");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
            Assert.That(result.Frequency, Is.EqualTo(1650));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC180_When180()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("180");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
            Assert.That(result.Frequency, Is.EqualTo(300));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC180_WhenCFC180()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("CFC 180");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
            Assert.That(result.Frequency, Is.EqualTo(300));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC60_When60()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("60");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
            Assert.That(result.Frequency, Is.EqualTo(100));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC60_WhenCFC60()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("CFC 60");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
            Assert.That(result.Frequency, Is.EqualTo(100));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC600_When600()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("600");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
            Assert.That(result.Frequency, Is.EqualTo(1000));
        }
        [Test]
        public void GetFilterClassFromString_ShouldReturnCFC600_WhenCFC600()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("CFC 600");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
            Assert.That(result.Frequency, Is.EqualTo(1000));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenInvalidInput()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("fg342");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
        }

        [Test]
        public void GetFilterClassFromString_ShouldReturnNone_WhenNone()
        {
            //Act & Assert
            var result = FilterClass.GetFilterClassFromString("None");
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
        }


        [Test]
        public void GetDefaultFilterClass_ShouldReturnUnfiltered_When0()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == '0').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnNone_WhenP()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'P').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenA()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'A').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenB()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'B').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenC()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'C').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenD()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'D').IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnAdhoc1700_WhenSAnd1700()
        {
            //Arrange
            softwareFilters.Find(p => p.ISOCode == 'S' && p.Frequency == 1700.00).IsDefault.Returns(true);

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
            Assert.That(result.Frequency, Is.EqualTo(1700.00));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenNull()
        {
            //Arrange
            softwareFilters = null;

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
        }

        [Test]
        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenEmptyCollection()
        {
            //Arrange
            softwareFilters = new List<ISoftwareFilter>();

            //Act & Assert
            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
        }


        [Test]
        public void GetFrequencyFromFilterClassType_ShouldReturn1650_WhenCFC1000()
        {
            //Act & Assert
            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.CFC1000);
            Assert.That(result, Is.EqualTo(1650));
        }

        [Test]
        public void GetFrequencyFromFilterClassType_ShouldReturn0_WhenNone()
        {
            //Act & Assert
            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.None);
            Assert.That(result, Is.EqualTo(0));
        }

        [Test]
        public void GetFrequencyFromFilterClassType_ShouldReturnMinus2_WhenUnfiltered()
        {
            //Act & Assert
            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.Unfiltered);
            Assert.That(result, Is.EqualTo(-2));
        }

        [Test]
        public void GetFrequencyFromFilterClassType_ShouldThrowException_WhenAdHoc()
        {
            //Act & Assert
            Assert.That(
              () => FilterClass.GetFrequencyFromFilterClassType(FilterClassType.AdHoc)
               , Throws.TypeOf<Exception>()
          .With
          .Property("Message")
          .EqualTo("GetFrequencyFromFilterClassType: AdHoc FilterClassType does not have frequency associated"));
        }
    }
}