public void SaveToFile_Test()
        {
            string tempXml = "unittest.temp.xml";

            foreach (var xml in goodXmlExamples)
            {
                var orig = new GranitXmlToAdapterBinder(xml, validate: true);

                long idToSelect1 = orig.HUFTransactionsAdapter.TransactionAdapters.Min(x => x.TransactionId);
                long idToSelect2 = orig.HUFTransactionsAdapter.TransactionAdapters.Max(x => x.TransactionId);

                orig.HUFTransactionsAdapter.TransactionAdapters[1].IsSelected = false;
                orig.HUFTransactionsAdapter.TransactionAdapters[orig.TransactionCount - 2].IsSelected = false;

                orig.SaveToFile(tempXml);
                var saved = new GranitXmlToAdapterBinder(tempXml, validate: true);
                int i     = 0;
                foreach (var t in saved.HUFTransactionsAdapter.TransactionAdapters)
                {
                    var origTransaction = orig.HUFTransactionsAdapter.TransactionAdapters[i++];

                    Assert.AreEqual(t.CompareTo(origTransaction), 0);
                }
            }
        }
        public void CompareGranitXDocuments_Test()
        {
            var x1 = new GranitXmlToAdapterBinder("example.xml", true);
            var x2 = new GranitXmlToAdapterBinder("test.xml", true);

            Assert.AreNotEqual(GranitXmlToAdapterBinder.CompareGranitXDocuments(x1.GranitXDocument, x2.GranitXDocument), 0);
        }
        public void AddTransactionRow_WithParameter_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                int origCount = x2o.TransactionCount;
                var newTa     = new TransactionAdapter();

                Assert.AreEqual(x2o.History.UndoCount, 0);

                x2o.AddTransactionRow(newTa);

                Assert.AreEqual(x2o.History.UndoCount, 1);

                Assert.AreEqual(x2o.GranitXDocument.Root.Elements().ToList().Count, origCount + 1);

                foreach (var ta in x2o.HUFTransactionsAdapter.TransactionAdapters)
                {
                    Assert.IsTrue(newTa.TransactionId >= ta.TransactionId);
                }

                Assert.AreEqual(x2o.GranitXDocument.Root.Elements(Constants.Transaction)
                                .Where(t => t.Attribute(Constants.TransactionIdAttribute).Value == newTa.TransactionId.ToString()).Count(), 1);
            }
        }
        public void GranitXmlToObjectBinder_Test()
        {
            var x2o = new GranitXmlToAdapterBinder();

            Assert.IsNotNull(x2o.GranitXDocument);
            Assert.IsNotNull(x2o.HUFTransactionsAdapter);
        }
        private static void Sort_UndoCount_Test(string xml, SortOrder order)
        {
            var x2o = new GranitXmlToAdapterBinder(xml, true);

            Assert.AreEqual(x2o.History.UndoCount, 0);
            x2o.Sort(Constants.ExecutionDatePropertyName, order);
            Assert.AreEqual(x2o.History.UndoCount, 1);
        }
 public void Validation_Succeded_Test()
 {
     foreach (var xml in goodXmlExamples)
     {
         var x2o = new GranitXmlToAdapterBinder(xml, true);
         Assert.AreEqual(x2o.XmlValidationErrorOccured, false);
     }
 }
 public void CompareGranitXDocuments_OneNull_Test()
 {
     foreach (var xml in goodXmlExamples)
     {
         var x2o = new GranitXmlToAdapterBinder(xml, true);
         Assert.AreEqual(GranitXmlToAdapterBinder.CompareGranitXDocuments(x2o.GranitXDocument, null), -1);
         Assert.AreEqual(GranitXmlToAdapterBinder.CompareGranitXDocuments(null, x2o.GranitXDocument), -1);
     }
 }
 public void AddEmptyTransactionRow_IncreasesTransactionCountByOne_Test()
 {
     foreach (var xml in goodXmlExamples)
     {
         var x2o       = new GranitXmlToAdapterBinder(xml, true);
         int origCount = x2o.HUFTransactionsAdapter.TransactionAdapters.Count;
         _ = x2o.AddEmptyTransactionRow();
         int afterCount = x2o.HUFTransactionsAdapter.TransactionAdapters.Count;
         Assert.AreEqual(origCount + 1, afterCount);
     }
 }
        public void AddEmptyTransactionRow_IncreasesUndocountByOne()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                Assert.AreEqual(x2o.History.UndoCount, 0);
                _ = x2o.AddEmptyTransactionRow();
                Assert.AreEqual(x2o.History.UndoCount, 1);
            }
        }
        public void GranitXmlDocContains_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);
                _ = x2o.TransactionCount;

                Assert.IsTrue(x2o.GranitXmlDocumentContains(x2o.HUFTransactionsAdapter.TransactionAdapters[0]));
                Assert.IsFalse(x2o.GranitXmlDocumentContains(new TransactionAdapter()));
                Assert.AreEqual(x2o.History.UndoCount, 0);
            }
        }
        public void AddEmptyTransactionRow_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                int origCount = x2o.TransactionCount;

                x2o.AddEmptyTransactionRow();

                Assert.AreEqual(x2o.History.UndoCount, 1);
                Assert.AreEqual(x2o.GranitXDocument.Root.Elements().ToList().Count, origCount + 1);
            }
        }
        public void TransactionId_Uniq_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                long previous_id = -1;
                foreach (var id in x2o.GranitXDocument.Root
                         .Elements(Constants.Transaction).Select(x => x.Attribute(Constants.TransactionIdAttribute).Value))
                {
                    Assert.AreNotEqual(previous_id, long.Parse(id));
                    previous_id = long.Parse(id);
                }
            }
        }
        public void AddEmptyTransactionRow_ReturnsWithTheLargestId_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                TransactionAdapter newTa = x2o.AddEmptyTransactionRow();
                foreach (var ta in x2o.HUFTransactionsAdapter.TransactionAdapters)
                {
                    Assert.IsTrue(newTa.TransactionId >= ta.TransactionId);
                }

                Assert.AreEqual(x2o.GranitXDocument.Root.Elements(Constants.Transaction)
                                .Where(t => t.Attribute(Constants.TransactionIdAttribute).Value == newTa.TransactionId.ToString()).Count(), 1);
            }
        }
        public void SaveToFile_Test()
        {
            string tempXml = "unittest.temp.xml";

            foreach (var xml in goodXmlExamples)
            {
                var orig = new GranitXmlToAdapterBinder(xml, validate: true);
                orig.SaveToFile(tempXml);
                var saved = new GranitXmlToAdapterBinder(tempXml, validate: true);
                int i     = 0;
                foreach (var t in saved.HUFTransactionsAdapter.TransactionAdapters)
                {
                    Assert.AreEqual(t.CompareTo(orig.HUFTransactionsAdapter.TransactionAdapters[i++]), 0);
                }
            }
        }
        public void RemoveTransactionRowById_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                int origCount = x2o.TransactionCount;
                Assert.AreEqual(x2o.History.UndoCount, 0);

                long idToRemove = x2o.HUFTransactionsAdapter.TransactionAdapters.Min(x => x.TransactionId);

                x2o.RemoveTransactionRowById(idToRemove);

                Assert.AreEqual(x2o.History.UndoCount, 1);
                Assert.AreEqual(x2o.GranitXDocument.Root.Elements().ToList().Count, origCount - 1);
                Assert.AreEqual(x2o.TransactionCount, origCount - 1);
            }
        }
        private static void Amount_Sort_and_MinMax_Test(string xml, SortOrder order)
        {
            var x2o = new GranitXmlToAdapterBinder(xml, true);

            x2o.Sort(Constants.AmountPropertyName, order);
            decimal maxAmount   = x2o.HUFTransactionsAdapter.TransactionAdapters.Max(ta => ta.Amount);
            decimal minAmount   = x2o.HUFTransactionsAdapter.TransactionAdapters.Min(ta => ta.Amount);
            string  firstAmount = x2o.GranitXDocument.Root.Elements(GranitXml.Constants.Transaction).First().Element(GranitXml.Constants.Amount).Value;
            string  lastAmount  = x2o.GranitXDocument.Root.Elements(GranitXml.Constants.Transaction).Last().Element(GranitXml.Constants.Amount).Value;

            string[] amounts  = x2o.GranitXDocument.Root.Elements(GranitXml.Constants.Transaction).Elements(GranitXml.Constants.Amount).Select(t => t.Value).ToArray();
            string   s_before = amounts[0];

            if (order == SortOrder.Descending)
            {
                Assert.AreEqual(decimal.Parse(firstAmount, NumberStyles.Number, CultureInfo.InvariantCulture),
                                maxAmount);
                Assert.AreEqual(decimal.Parse(lastAmount, NumberStyles.Number, CultureInfo.InvariantCulture),
                                minAmount);
                foreach (var s in amounts)
                {
                    Assert.IsTrue(
                        decimal.Parse(s_before, NumberStyles.Number, CultureInfo.InvariantCulture) >=
                        decimal.Parse(s, NumberStyles.Number, CultureInfo.InvariantCulture));
                    s_before = s;
                }
            }
            else
            {
                Assert.AreEqual(decimal.Parse(firstAmount, NumberStyles.Number, CultureInfo.InvariantCulture),
                                minAmount);
                Assert.AreEqual(decimal.Parse(lastAmount, NumberStyles.Number, CultureInfo.InvariantCulture),
                                maxAmount);
                foreach (var s in amounts)
                {
                    Assert.IsTrue(
                        decimal.Parse(s_before, NumberStyles.Number, CultureInfo.InvariantCulture) <=
                        decimal.Parse(s, NumberStyles.Number, CultureInfo.InvariantCulture));
                    s_before = s;
                }
            }
            Assert.AreEqual(x2o.History.UndoCount, 1);
        }
        public void AddTransactionRow_ExistingTAdapter_Test()
        {
            foreach (var xml in goodXmlExamples)
            {
                var x2o = new GranitXmlToAdapterBinder(xml, true);

                int origCount = x2o.TransactionCount;

                var newTa = x2o.HUFTransactionsAdapter.TransactionAdapters[0];

                Assert.AreEqual(x2o.History.UndoCount, 0);

                x2o.AddTransactionRow(newTa);

                Assert.AreEqual(x2o.History.UndoCount, 0);
                Assert.AreEqual(x2o.GranitXDocument.Root.Elements().ToList().Count, origCount);

                Assert.AreEqual(x2o.GranitXDocument.Root.Elements(GranitXml.Constants.Transaction)
                                .Where(t => t.Attribute(GranitXml.Constants.TransactionIdAttribute).Value == newTa.TransactionId.ToString()).Count(), 1);
            }
        }
        private static void Sort_ReqDate_Test(string xml, SortOrder order)
        {
            var x2o = new GranitXmlToAdapterBinder(xml, true);

            x2o.Sort(Constants.ExecutionDatePropertyName, order);

            DateTime maxDate   = x2o.HUFTransactionsAdapter.TransactionAdapters.Max(ta => ta.ExecutionDate);
            DateTime minDate   = x2o.HUFTransactionsAdapter.TransactionAdapters.Min(ta => ta.ExecutionDate);
            string   firstDate = x2o.GranitXDocument.Root.Elements(Constants.Transaction).InDocumentOrder().First().Element(Constants.RequestedExecutionDate).Value;
            string   lastDate  = x2o.GranitXDocument.Root.Elements(Constants.Transaction).InDocumentOrder().Last().Element(Constants.RequestedExecutionDate).Value;

            if (order == SortOrder.Descending)
            {
                Assert.AreEqual(DateTime.Parse(firstDate), maxDate);
                Assert.AreEqual(DateTime.Parse(lastDate), minDate);
            }
            else
            {
                Assert.AreEqual(DateTime.Parse(firstDate), minDate);
                Assert.AreEqual(DateTime.Parse(lastDate), maxDate);
            }
        }
        public void Validation_Fails_On_Errorneous_XML_Test()
        {
            var x2o = new GranitXmlToAdapterBinder("bad_example.xml", true);

            Assert.AreEqual(x2o.XmlValidationErrorOccured, true);
        }
 public void CompareGranitXDocuments_BothNull_Test()
 {
     Assert.AreEqual(GranitXmlToAdapterBinder.CompareGranitXDocuments(null, null), 0);
 }