Ejemplo n.º 1
0
        public async void When_provisioning_along_with_custom_properties()
        {
            var properties = new Dictionary<string, EntityProperty>
            {
                {"Created", new EntityProperty(DateTimeOffset.Now)},
                {"Active",  new EntityProperty(true)}
            };

            var stream = await Stream.ProvisionAsync(partition, StreamProperties.From(properties));
            var entity = partition.RetrieveStreamEntity();

            var expectedStream = new Stream
            (
                partition,
                entity.ETag, 0, 
                StreamProperties.From(properties)
            );

            stream.ShouldEqual(expectedStream.ToExpectedObject());

            var expectedEntity = new
            {
                RowKey = Api.StreamRowKey,
                Properties = StreamProperties.From(properties),
                Version = 0
            };

            entity.ShouldMatch(expectedEntity.ToExpectedObject());
        }
Ejemplo n.º 2
0
        public async void When_partition_is_virgin()
        {
            var stream = await Stream.ProvisionAsync(partition);
            var entity = partition.RetrieveStreamEntity();
            
            var expectedStream = new Stream(partition, entity.ETag, 0, StreamProperties.None);
            stream.ShouldEqual(expectedStream.ToExpectedObject());

            var expectedEntity = new
            {
                RowKey = Api.StreamRowKey,
                Version = 0
            };

            entity.ShouldMatch(expectedEntity.ToExpectedObject());
        }
Ejemplo n.º 3
0
        public void Test_Order_Group_Sum_By_Revenue()
        {
            var orderHelper = new OrderHelper();

            var expected = new[] { 50, 66, 60 };

            int productCountLimit = 4;
            var actual = orderHelper.GetOrderSum(Orders, "Revenue", productCountLimit);

            expected.ToExpectedObject().ShouldEqual(actual.ToArray());
        }
Ejemplo n.º 4
0
        public void Test_Order_Group_Sum_By_Cost()
        {
            var orderHelper = new OrderHelper();

            var expected = new[] { 6, 15, 24, 21 };

            int productCountLimit = 3;
            var actual = orderHelper.GetOrderSum(Orders, "Cost", productCountLimit);

            expected.ToExpectedObject().ShouldEqual(actual.ToArray());
        }
        static void AssertEventIdEntity(string id, int version, EventIdEntity actual)
        {
            var expected = new
            {
                RowKey = id.FormatEventIdRowKey(),
                Version = version,
            };

            actual.ShouldMatch(expected.ToExpectedObject());
        }
        static void AssertEventEntity(int version, EventEntity actual)
        {
            var expected = new
            {
                RowKey = version.FormatEventRowKey(),
                Properties = EventProperties.From(new Dictionary<string, EntityProperty>
                {
                    {"Type", new EntityProperty("StreamChanged")},
                    {"Data", new EntityProperty("{}")},
                }),
                Version = version,
            };

            actual.ShouldMatch(expected.ToExpectedObject());
        }
        void AssertStreamEntity(int version = 0, object properties = null)
        {
            var newStreamEntity = partition.RetrieveStreamEntity();

            var expectedEntity = new
            {
                RowKey = Api.StreamRowKey,
                Properties = properties != null
                    ? StreamProperties.From(properties)
                    : StreamProperties.None,
                Version = version,
            };

            newStreamEntity.ShouldMatch(expectedEntity.ToExpectedObject());
        }
Ejemplo n.º 8
0
        public void Test_PartialCompare_Person_Equals_with_ExpectedObjects()
        {
            // 透過匿名型別,只比較property的value是否相等
            var expected = new
            {
                Id = 1,
                Age = 10,
                Order = new { Id = 91 },
            };

            var actual = new Person
            {
                Id = 1,
                Name = "B",
                Age = 10,
                Order = new Order { Id = 91, Price = 910 },
            };

            //expected.ToExpectedObject().ShouldEqual(actual);
            expected.ToExpectedObject().ShouldMatch(actual);
        }