right so we now need to display the balance, this is quite simple as we have a text box that is set to read only, and the balance is available form the engine, now we could add this balance to the current data grid controller, but I think the name is wrong so I shall rename it to the MoneyEngineController, so this will control all actions on the form.

looking at the controller code we can see that the only time the data is loaded is when the grid is bound, I think I will move that command up into the constructor, so when we create the controller, the data from the database is loaded ready, this will simplify the testing of the balance display and also leaves the data grid binding command doing a single thing, binding the data grid to the data source.

so we need a simple test to ensure we display the balance, I did a bit of refactoring on the test code, and ended up with the following test class

    [TestFixture]
    public class MoneyEngineControllerTests
    {
        ThinkingOfMoney.Controller.MoneyEngineController _Controller;

        [SetUp]
        public void SetupForTest()
        {
            _Controller = new ThinkingOfMoney.Controller.MoneyEngineController();
        }

        [Test]
        public void Hook()
        {
            Assert.IsTrue(true);
        }

        [Test]
        public void Create()
        {
            Assert.IsNotNull(_Controller);
        }

        [Test]
        public void BindDataGrid()
        {
            System.Windows.Forms.DataGridView gridView = new System.Windows.Forms.DataGridView();

            _Controller.BindDataGrid(gridView);

            Assert.IsTrue(gridView.Rows.Count == 0);
        }

        [Test]
        public void BindBalance()
        {
            System.Windows.Forms.TextBox txtBalance = new System.Windows.Forms.TextBox();
            _Controller.BindBalanceTextBox(txtBalance);

            Assert.IsTrue(txtBalance.Text.Length > 0, txtBalance.Text);
        }
    }

and the following code is now making up the controller, notice that I have formatted the output string(I found the information here) , and moved the loading code to the constructor.

    class MoneyEngineController
    {
        MoneyEngine.MoneyEngine _Engine;

        /// <summary>
        /// Initializes a new instance of the DataGridController class.
        /// </summary>
        public MoneyEngineController()
        {
            _Engine = new MoneyEngine.MoneyEngine();
            _Engine.LoadTransactions();         
        }

        public void BindDataGrid(System.Windows.Forms.DataGridView gridView)
        {
            gridView.DataSource = _Engine.History;
        }

        public void BindBalanceTextBox(System.Windows.Forms.TextBox txtBalance)
        {
            txtBalance.Text = string.Format("{0:c}", _Engine.Balance);
        }
    }

ok the test passes, we need to add the call to the form code, and run the form!

and the balance displays as zero, I was expecting more than that as some of the transactions have values in, so we do have a problem somewhere, looking at the code when we load the transactions from the database then the balance is not updated, so a quick change of code here, but first a test to prove the error and fix

        [Test]
        public void BalanceAfterLoad()
        {
            _Engine.LoadTransactions();

            Assert.IsTrue(_Engine.Balance > 0, "balance should be greater than zero");
        }

and as expected it fails, so now to update the load transactions method, to get a pass, first off started by changing the load class so it would use the available add and subtract routines that add too and subtract from the balance already, but I needed to be able to add the transaction id so update would work correctly

    public bool LoadTransactions()
        {
            DBMoneyEngine database = new DBMoneyEngine();
            DataTable transactions = database.GetTransactionsInDateOrder(ref _ErrorText);

            if (transactions == null)
                return false;

            if (transactions.Rows.Count > 0)
            {
                foreach (DataRow transData in transactions.Rows)
                {
                    Int32 transID = transData["TransID"] is DBNull ? 0 : Convert.ToInt32(transData["TransID"]);
                    TransactionType transType = transData["TransType"] is DBNull ? 

TransactionType.AdditionTransaction : (int) transData["TransType"] == 0 ? 

TransactionType.AdditionTransaction : TransactionType.SubtractionTransaction;
                    DateTime transDate = transData["TransDate"] is DBNull ? DateTime.Now : 

(DateTime) transData["TransDate"];
                    string transCategory = transData["TransCategory"] is DBNull ? string.Empty : 

transData["TransCategory"].ToString();
                    string transDescription = transData["TransDescription"] is DBNull ? string.Empty : 

transData["TransDescription"].ToString();
                    double transAmount = transData["TransAmount"] is DBNull ? 0 : 

(double)transData["TransAmount"];                     

                    if (transType == TransactionType.AdditionTransaction)
                        AddTransaction(transID, transAmount, transCategory, transDescription, transDate);

                    if (transType == TransactionType.SubtractionTransaction)
                        SubtractTransaction(transID, transAmount, transCategory, transDescription, transDate);
                }
            }

            return true;
        }

 This change required that the addition and subtraction routines were overloaded with a private method that took the transaction ID, the previous methods simply handed in 0 as a transaction id.

        private bool AddTransaction(int transID, double amount, string category, string description, 

DateTime transactionDate)
        {
            MoneyTransaction trans = new MoneyTransaction(transID, amount, category, description, 

transactionDate, TransactionType.AdditionTransaction);
            _History.Add(trans);

            _Balance += trans.TransactionAmount;

            return true;
        }

        public bool AddTransaction(double amount, string category, string description, DateTime transactionDate)
        {
            return AddTransaction(0, amount, category, description, transactionDate);
        }

        private bool SubtractTransaction(int transID, double amount, string category, string description, 

DateTime transactionDate)
        {
            MoneyTransaction trans = new MoneyTransaction(transID, amount, category, description, 

transactionDate, TransactionType.SubtractionTransaction);
            _History.Add(trans);

            _Balance -= trans.TransactionAmount;

            return true;
        }

        public bool SubtractTransaction(double amount, string category, string description, 

DateTime transactionDate)
        {
            return SubtractTransaction(0, amount, category, description, transactionDate);
        }

A quick run of all the tests confirms that we haven’t broken anything, you will also notice form the following screen shot that I changed the order in that the data is returned, and set the formatting on the account column, so that it matches the balance.

So next is the transaction addition

OK so I have tested the binding, and made sure that what I thought might work did, transferring this to our formal code means we need a way to test it as close to the interface as possible, personally I believe for programmer unit testing it is impossible to test actually at the interface short of actually clicking on the buttons.

My current way, and I am always open to suggestions, is to use a model view controller pattern, the model in this case is the engine, the view is the form and the controller will communicate between them both, and it is here that my testing will stop, so I want zero code if possible in the form, and all the code that is usually in the form within the controller.

so to the unit tests which look like this.

   [TestFixture]
    public class DataGridControllerTests
    {
        [Test]
        public void Hook()
        {
            Assert.IsTrue(true);
        }

        [Test]
        public void Create()
        {
            Assert.IsNotNull(new ThinkingOfMoney.Controller.DataGridController());
        }

        [Test]
        public void BindDataGrid()
        {
            System.Windows.Forms.DataGridView gridView = new System.Windows.Forms.DataGridView();

            DataGridController controller = new DataGridController();
            controller.BindDataGrid(gridView);

            Assert.IsTrue(gridView.Rows.Count == 0);
        }
    }

This is our usual hook and a create, the BindDataGrid is where the interest will happen it takes our forms grid , the test then ensures we have some rows when the function returns.

The controller code looks like this

    class DataGridController
    {
        MoneyEngine.MoneyEngine _Engine;

        public DataGridController()
        {
            _Engine = new MoneyEngine.MoneyEngine();                      
        }

        public void BindDataGrid(System.Windows.Forms.DataGridView gridView)
        {
            _Engine.LoadTransactions();

            gridView.DataSource = _Engine.History;
        }
    }

The controller creates a new money engine in its constructor, providing the link to the model, so the form dosn’t actually have any direct contact with the money engine at all.

The BindDataGrid method takes a data grid view as a parameter, and loads all the transactions, then the data grid view data source property is set to the engine history collection.

Finally we have to create the loading code for the main form

    public partial class frmMain : Form
    {
        public frmMain()
        {
            InitializeComponent();

            Controller.DataGridController gridController = new ThinkingOfMoney.Controller.DataGridController();
            gridController.BindDataGrid(dgvHistory);
        }
    }

This is the bit we cant test, so it has to be as basic as possible, now we can run the project and see how the user interface fills out.

so next we need to display the balance, and be able to add and update the transactions

It took a while to figure out correctly but by adding the grid to the form and opening the data grid view task, I selected the object data source

and then clicked next, ok so we want to display money engine transactions, this is important, what we are selecting on this screen is the row item we are going to display, this took me a bit of time to get my head around, it helped me to see it as defining the columns that would be displayed, first select the transaction object, which has all the properties of a transaction, and click next

press finish with money transactions selected, and you are returned to the main form, but this time the grid has all the basic column names filled out, now we need to edit the grid column names so that only the ones we are interested in are shown.

So now with this basic configuration done its back to the code.

when I was trying out this I used a new form and simply dropped the datagrid onto in, and set it up to fill the form, I wanted to quickly understand the binding technique, and what code was required to bind the collection to the form, this ended up as follows

       public Form1()
        {
            InitializeComponent();

            MoneyEngine.MoneyEngine engine = new MoneyEngine.MoneyEngine();
            engine.LoadTransactions();

            dataGridView1.DataSource = engine.History;
        }

it turned out that simply loading the money engine, and then binding the engine history, which is a collection of transactions, this automatically fills the grid, like so

having tested the theory we setup the main gird on the money form the same way, however in keeping with our wish to test as much as possible, we will move the binding code into a controller module, which we can test in the usual way, 

know I did all of this without running any unit tests, but sometimes I find its easier just to breakout a quick form and try out some quick code, especially when it involves using Visual Studio wizards.  As long as when we transfer the code into the main project, we create tests that will ensure that it works and any changes are caught things should be fine.

which we shall do next time.