tbf/TBFTests/Rig/Uni/SharedDialogs/SmartMetersCommunication/SmartCommunicationFormTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TBF.Rig.RegisterReaders.AllyReader;
using TBF.Rig.RegisterReaders.GenesisRegReader.implementations;
using TBF.Rig.Sequences;
using TBF.Rig.Uni.SharedDialogs.SmartMetersCommunication;
using TBF.Rig.Uni.SharedDialogs.SmartMetersCommunication.common;
using TBF.Rig.Uni.SharedDialogs.SmartMetersCommunication.implementations;

namespace TBFTests.Rig.Uni.SharedDialogs.SmartMetersCommunication
{
    [TestClass]
    public class SmartCommunicationFormTests
    {
        private static readonly object ProcessDataLock = new object();

        [TestMethod]
        public void ManualForm_PopulatesAvailableFamiliesFromRegisterReaders()
        {
            RunInSta(() =>
            {
                WithSmartReaders(new ISmartReader[] { CreateGenesisReader(), CreateAllyReader() }, () =>
                {
                    using (var form = new SmartCommunicationForm(true))
                    {
                        CollectionAssert.AreEqual(
                            new[] { "Genesis", "ALLY" },
                            SmartCommunicationForm.IdentifyReaderTypes());
                    }
                });
            });
        }

        [TestMethod]
        public void ManualForm_SelectedFamilyPopulatesOnlyMatchingReaderAndCorrection()
        {
            RunInSta(() =>
            {
                GenesisSmartReader genesis = CreateGenesisReader();
                AllyMeterReader ally = CreateAllyReader();
                WithSmartReaders(new ISmartReader[] { genesis, ally }, () =>
                {
                    using (var form = new SmartCommunicationForm(true))
                    {
                        SelectFamily(form, "ALLY");
                        Assert.AreEqual(1, form.Heads.Count);
                        Assert.AreSame(ally, form.Heads[0]);
                        Assert.IsInstanceOfType(CurrentCorrection(), typeof(AllyCorrections));

                        SelectFamily(form, "Genesis");
                        Assert.AreEqual(1, form.Heads.Count);
                        Assert.AreSame(genesis, form.Heads[0]);
                        Assert.IsInstanceOfType(CurrentCorrection(), typeof(GenesisCorrections));
                    }
                });
            });
        }

        [TestMethod]
        public void ManualForm_LoadsReaderRowsAndCheckboxTogglesSelectionState()
        {
            RunInSta(() =>
            {
                AllyMeterReader first = CreateAllyReader();
                AllyMeterReader second = CreateAllyReader();
                WithSmartReaders(new ISmartReader[] { first, second }, () =>
                {
                    using (var form = new SmartCommunicationForm(true))
                    {
                        SelectFamily(form, "ALLY");
                        form.CkbIndex[0] = 0;
                        form.CkbIndex[1] = 1;
                        ICorrections correction = CurrentCorrection();
                        correction.Load(form.Labels, form.Counters, form.Messages, form.CheckBoxes,
                            form.CkbIndex, form.CkbState, form.Heads, form.CheckBoxes.Length, true);

                        Assert.AreEqual(2, form.Heads.Count);
                        Assert.AreSame(first, form.Heads[0]);
                        Assert.AreSame(second, form.Heads[1]);
                        Assert.IsTrue(form.CheckBoxes[0].Checked);
                        Assert.IsTrue(form.CheckBoxes[1].Checked);
                        Assert.AreEqual("---", form.Messages[0].Text);
                        Assert.AreEqual("---", form.Messages[1].Text);

                        form.CheckBoxes[0].Checked = false;
                        InvokePrivate(form, "checkBoxImage1_Click", form.CheckBoxes[0], EventArgs.Empty);
                        Assert.IsFalse(form.CkbState[0]);

                        form.CheckBoxes[0].Checked = true;
                        InvokePrivate(form, "checkBoxImage1_Click", form.CheckBoxes[0], EventArgs.Empty);
                        Assert.IsTrue(form.CkbState[0]);
                        Assert.IsTrue((form.GetCheckBoxStates() & 1L) != 0L);
                    }
                });
            });
        }

        [TestMethod]
        public void SelectedCorrection_ProvidesCommandsForTheSelectedRegisterReaderFamily()
        {
            RunInSta(() =>
            {
                WithSmartReaders(new ISmartReader[] { CreateGenesisReader(), CreateAllyReader() }, () =>
                {
                    using (var form = new SmartCommunicationForm(true))
                    {
                        SelectFamily(form, "ALLY");
                        CollectionAssert.Contains(
                            CurrentCorrection().GetContextMenu().MenuItems.Cast<System.Windows.Forms.MenuItem>()
                                .Select(item => item.Text).ToArray(),
                            "Read Serial Number");

                        SelectFamily(form, "Genesis");
                        CollectionAssert.Contains(
                            CurrentCorrection().GetContextMenu().MenuItems.Cast<System.Windows.Forms.MenuItem>()
                                .Select(item => item.Text).ToArray(),
                            "Read PCB Number");
                    }
                });
            });
        }

        private static AllyMeterReader CreateAllyReader()
        {
            return new AllyMeterReader(new AllyReaderCfg(new TBF.Rig.RegisterReaders.AllyReader.Factory()));
        }

        private static GenesisSmartReader CreateGenesisReader()
        {
            return new GenesisSmartReader(new TBF.Rig.RegisterReaders.GenesisRegReader.GenesisCfg(
                new TBF.Rig.RegisterReaders.GenesisRegReader.Factory()));
        }

        private static void SelectFamily(SmartCommunicationForm form, string family)
        {
            SmartCommunicationForm.SelectedTypeReader = family;
            InvokePrivate(form, "UpdateHeads");
        }

        private static ICorrections CurrentCorrection()
        {
            PropertyInfo property = typeof(SmartCommunicationForm).GetProperty(
                "Correction", BindingFlags.NonPublic | BindingFlags.Static);
            return (ICorrections)property.GetValue(null, null);
        }

        private static void InvokePrivate(SmartCommunicationForm form, string methodName, params object[] parameters)
        {
            MethodInfo method = typeof(SmartCommunicationForm).GetMethod(
                methodName, BindingFlags.NonPublic | BindingFlags.Instance);
            method.Invoke(form, parameters);
        }

        private static void WithSmartReaders(IList<ISmartReader> readers, Action action)
        {
            lock (ProcessDataLock)
            {
                IList<ISmartReader> previous = ProcessData.SmartHeadsUni;
                string previousSelectedType = SmartCommunicationForm.SelectedTypeReader;
                try
                {
                    ProcessData.SmartHeadsUni = readers;
                    SmartCommunicationForm.SelectedTypeReader = null;
                    action();
                }
                finally
                {
                    ProcessData.SmartHeadsUni = previous;
                    SmartCommunicationForm.SelectedTypeReader = previousSelectedType;
                }
            }
        }

        private static void RunInSta(Action action)
        {
            Exception failure = null;
            Thread thread = new Thread(() =>
            {
                try { action(); }
                catch (Exception exception) { failure = exception; }
            });
            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
            thread.Join();
            if (failure != null)
                throw new AssertFailedException(failure.ToString());
        }
    }
}