Пример #1
0
        public void TestNoValidationAttributes()
        {
            // ARRANGE
            const string   sample    = "EdiWeave.UnitTests.X12.Edi.X12_810_00204.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040.NoValidation"))
            {
                ediItems = ediReader.ReadToEnd().ToList();
            }
            var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);

            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <TS810NoValidation>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
            Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #2
0
        public void TestCrLf()
        {
            // ARRANGE
            const string   sample    = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_CRLF.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;
            Separators     separators;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
            {
                ediItems   = ediReader.ReadToEnd().ToList();
                separators = ediReader.Separators;
            }
            var actual = X12Helper.Generate(ediItems, separators, "\n");

            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
            Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #3
0
        public void TestMultipleInterchange()
        {
            // ARRANGE
            const string sample    = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_MultipleInterchanges.txt";
            var          ediStream = CommonHelper.LoadStream(sample);
            var          expected  = CommonHelper.LoadString(sample);
            var          ediItems  = new List <EdiItem>();

            // ACT
            var actual = "";

            using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
            {
                while (ediReader.Read())
                {
                    if (ediReader.Item is ISA && ediItems.Any())
                    {
                        actual = actual + X12Helper.Generate(ediItems, null, Environment.NewLine);
                        ediItems.Clear();
                    }

                    ediItems.Add(ediReader.Item);
                }

                actual = actual + X12Helper.Generate(ediItems, ediReader.Separators, Environment.NewLine);
            }

            // ASSERT
            Assert.AreEqual(expected, actual);
        }
Пример #4
0
        public void TestLoadingWithDelegate()
        {
            // ARRANGE
            const string   sample    = "EdiFabric.UnitTests.X12.Edi.X12_810_00204.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;

            // ACT
            using (var ediReader = new X12Reader(ediStream, AssemblyLoadFactory))
            {
                ediItems = ediReader.ReadToEnd().ToList();
            }
            var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);

            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
            Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #5
0
        public void TestBlankRepetition()
        {
            // ARRANGE
            const string   sample      = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_BlankRepetition.txt";
            const string   cleanSample = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_BlankRepetitionClean.txt";
            var            ediStream   = CommonHelper.LoadStream(sample);
            var            expected    = CommonHelper.LoadString(cleanSample);
            List <EdiItem> ediItems;
            Separators     separators;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiFabric.Rules.X12002040"))
            {
                ediItems   = ediReader.ReadToEnd().ToList();
                separators = ediReader.Separators;
            }
            var actual = X12Helper.Generate(ediItems, separators, Environment.NewLine);


            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
            Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #6
0
        public void TestBom()
        {
            // ARRANGE
            const string   sample    = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_BOM.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
            {
                ediItems = ediReader.ReadToEnd().ToList();
            }
            var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);

            // ASSERT
            Assert.AreEqual(expected, actual);
        }
Пример #7
0
        private static void Main(string[] args)
        {
            // This sample will generate an EDI message from a custom object. The steps are:
            // 1. It creates an Interchange out of a single custom object.
            // For simplicity the custom object bears the same structure as the ediFabric object. The only difference being the root element and the namespace
            // 2. Validates the Message object to ensure it adheres to the EDI rules for this transaction and version
            // 3. Converts the Interchange into a list of segments. This way any preference on postfixes can be attached at the end of each segment.
            // 4. Converts the list of segments into a real EDI message with CRLF postfix
            // The default locations for the transaction set classes and validation XSD are set in the app.config

            // This sample is for Edifact and uses a compiled XSLT map to convert from custom object to ediFabric object
            var ediFactInterchange = EdifactHelper.CreateInterchange(EdifactHelper.CreateSampleCustomInvoic());
            var ediFactSegments    = ediFactInterchange.ToEdi();
            var ediFactInvoice     = ediFactSegments.Aggregate("", (current, segment) => current + segment + Environment.NewLine);

            // This sample is for X12 and uses a code map (I used Automapper, but could be any custom code\mapper) to convert from custom object to ediFabric object
            var x12Interchange = X12Helper.CreateInterchange(X12Helper.CreateSampleCustom810());
            var x12Segments    = x12Interchange.ToEdi();
            var x12Invoice     = x12Segments.Aggregate("", (current, segment) => current + segment + Environment.NewLine);
        }
Пример #8
0
        public void TestDuplicateSeparator()
        {
            // ARRANGE
            const string   sample    = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_RepetitionSeparator.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;
            Separators     separators;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiFabric.Rules.X12002040.Rep"))
            {
                ediItems   = ediReader.ReadToEnd().ToList();
                separators = ediReader.Separators;
            }
            var actual = X12Helper.Generate(ediItems, separators, Environment.NewLine);

            // ASSERT
            Assert.AreEqual(expected, actual);
        }
Пример #9
0
        public void Test5010Hl()
        {
            // ARRANGE
            const string   sample    = "EdiFabric.UnitTests.Hipaa.Edi.Hipaa_837P_00501_HL.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;

            // ACT
            using (var ediReader = new X12Reader(ediStream, HipaaFactory))
            {
                ediItems = ediReader.ReadToEnd().ToList();
            }
            var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);

            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #10
0
        public void Test5010Lfnm1Lisa()
        {
            // ARRANGE
            const string   sample    = "EdiWeave.UnitTests.Hipaa.Edi.Hipaa_837P_00501_LF.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;
            Separators     separators;

            // ACT
            using (var ediReader = new X12Reader(ediStream, HipaaFactory))
            {
                ediItems   = ediReader.ReadToEnd().ToList();
                separators = ediReader.Separators;
            }
            var actual = X12Helper.Generate(ediItems, separators, "");

            // ASSERT
            Assert.IsNotNull(ediItems);
            Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
            Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }
Пример #11
0
        public void TestNoPreserveWhiteSpace()
        {
            // ARRANGE
            const string sample   = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_WriteNoPreserveWhitespace.txt";
            var          expected = CommonHelper.LoadString(sample);
            string       actual;

            // ACT
            using (var stream = new MemoryStream())
            {
                var writer = new X12Writer(stream, Encoding.UTF8, Environment.NewLine);

                writer.Write(X12Helper.CreateIsa());
                writer.Write(X12Helper.CreateGs());
                writer.Write(X12Helper.CreateInvoice());
                writer.Flush();

                actual = CommonHelper.LoadString(stream);
            }

            // ASSERT
            Assert.AreEqual(expected, actual);
        }
Пример #12
0
        public void TestMultipleMessages()
        {
            // ARRANGE
            const string   sample    = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_MultipleMessages.txt";
            var            ediStream = CommonHelper.LoadStream(sample);
            var            expected  = CommonHelper.LoadString(sample);
            List <EdiItem> ediItems;

            // ACT
            using (var ediReader = new X12Reader(ediStream, "EdiFabric.Rules.X12002040"))
            {
                ediItems = ediReader.ReadToEnd().ToList();
            }
            var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);

            // ASSERT
            Assert.IsTrue(ediItems.OfType <TS810>().Count() == 2);
            Assert.IsTrue(ediItems.OfType <ISA>().Count() == 1);
            Assert.IsTrue(ediItems.OfType <GS>().Count() == 1);
            Assert.IsTrue(ediItems.OfType <GE>().Count() == 1);
            Assert.IsTrue(ediItems.OfType <IEA>().Count() == 1);
            Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
            Assert.AreEqual(expected, actual);
        }