Exemplo n.º 1
0
        public void FindDifferences_handles_old_null()
        {
            var oldState = new TheVictim
            {
                String = "old string"
            };

            worker.FindDifferences(oldState, null, stateChanges, 5);

            Assert.Equal(1, stateChanges.Changes.Count);

            var change = stateChanges.Changes[0];

            Assert.Equal("String", change.Breadcrumb);
            Assert.Equal("old string", change.OldValue);
            Assert.Null(change.NewValue);
        }
Exemplo n.º 2
0
        public void FindDifferences_works()
        {
            var dt = DateTime.Now;
            var ts = TimeSpan.FromDays(1.234);

            var oldState = new TheVictim
            {
                Bool      = true,
                Char      = 'c',
                DateTime  = dt,
                Decimal   = 123.45m,
                Double    = 12.34,
                Float     = 6.66f,
                Int       = 666,
                String    = "Kewl string",
                TimeSpan  = ts,
                Enum      = EnumVictim.One,
                Byte      = 5,
                SomeThing = new SomeThing
                {
                    SomeString = "Some"
                },
                InternalIsIncluded = "internal"
            }.SetPrivate("private").SetProtected("protected");

            var newState = new TheVictim()
            {
                Bool      = false,
                Char      = 'x',
                DateTime  = dt.AddMinutes(2.1),
                Decimal   = 123.50m,
                Double    = 12.56,
                Float     = 6.78f,
                Int       = 777,
                String    = "Hot string",
                TimeSpan  = ts.Add(TimeSpan.FromMinutes(2.3)),
                Enum      = EnumVictim.Two,
                Byte      = 9,
                SomeThing = new SomeThing
                {
                    SomeString = "Changed"
                },
                InternalIsIncluded = "changed internal"
            }.SetPrivate("changed").SetProtected("changed protected");

            worker.FindDifferences(oldState, newState, stateChanges, 5);

            Assert.Equal(15, stateChanges.Changes.Count);

            var sorted = stateChanges.Changes.OrderBy(x => x.Breadcrumb).ToList();

            var change = sorted[0];

            Assert.Equal("Bool", change.Breadcrumb);
            Assert.Equal(true, change.OldValue);
            Assert.Equal(false, change.NewValue);

            change = sorted[1];
            Assert.Equal("Byte", change.Breadcrumb);
            Assert.Equal((byte)5, change.OldValue);
            Assert.Equal((byte)9, change.NewValue);

            change = sorted[2];
            Assert.Equal("Char", change.Breadcrumb);
            Assert.Equal('c', change.OldValue);
            Assert.Equal('x', change.NewValue);

            change = sorted[3];
            Assert.Equal("DateTime", change.Breadcrumb);
            Assert.Equal(oldState.DateTime, change.OldValue);
            Assert.Equal(newState.DateTime, change.NewValue);

            change = sorted[4];
            Assert.Equal("Decimal", change.Breadcrumb);
            Assert.Equal(123.45m, change.OldValue);
            Assert.Equal(123.50m, change.NewValue);

            change = sorted[5];
            Assert.Equal("Double", change.Breadcrumb);
            Assert.Equal(12.34, change.OldValue);
            Assert.Equal(12.56, change.NewValue);

            change = sorted[6];
            Assert.Equal("Enum", change.Breadcrumb);
            Assert.Equal(EnumVictim.One, change.OldValue);
            Assert.Equal(EnumVictim.Two, change.NewValue);

            change = sorted[7];
            Assert.Equal("Float", change.Breadcrumb);
            Assert.Equal(6.66f, change.OldValue);
            Assert.Equal(6.78f, change.NewValue);

            change = sorted[8];
            Assert.Equal("Int", change.Breadcrumb);
            Assert.Equal(666, change.OldValue);
            Assert.Equal(777, change.NewValue);

            change = sorted[9];
            Assert.Equal("InternalIsIncluded", change.Breadcrumb);
            Assert.Equal("internal", change.OldValue);
            Assert.Equal("changed internal", change.NewValue);

            change = sorted[10];
            Assert.Equal("PrivateIsIncluded", change.Breadcrumb);
            Assert.Equal("private", change.OldValue);
            Assert.Equal("changed", change.NewValue);

            change = sorted[11];
            Assert.Equal("ProtectedIsIncluded", change.Breadcrumb);
            Assert.Equal("protected", change.OldValue);
            Assert.Equal("changed protected", change.NewValue);

            change = sorted[12];
            Assert.Equal("SomeThing.SomeString", change.Breadcrumb);
            Assert.Equal("Some", change.OldValue);
            Assert.Equal("Changed", change.NewValue);

            change = sorted[13];
            Assert.Equal("String", change.Breadcrumb);
            Assert.Equal("Kewl string", change.OldValue);
            Assert.Equal("Hot string", change.NewValue);

            change = sorted[14];
            Assert.Equal("TimeSpan", change.Breadcrumb);
            Assert.Equal(oldState.TimeSpan, change.OldValue);
            Assert.Equal(newState.TimeSpan, change.NewValue);
        }