Exemple #1
0
            public ClientProspectiveSaleModel Select(Guid saleId)
            {
                var responseSpecification = ResponseSpecification.Create <ClientProspectiveSaleModel>();
                var response = server.Select(saleId, responseSpecification);

                return(JsonConvert.DeserializeObject <ClientProspectiveSaleModel>(response));
            }
        public void Test_Contract_With_Custom_Names()
        {
            var actual   = ResponseSpecification.Create <CustomNamesType>();
            var expected = ResponseSpecification
                           .Field("A")
                           .Field("B")
                           .Field("C")
                           .Field("custom1")
                           .Field("E")
                           .Field("F")
                           .Field("custom2")
                           .Field("custom3")
                           .Field("custom4")
                           .Create();

            actual.ShouldBeEquivalentTo(expected);
        }
        public void Test_Create_For_Complex_Type()
        {
            var actual   = ResponseSpecification.Create <ComplexType>();
            var expected = ResponseSpecification
                           .Field("A")
                           .Field("B")
                           .Field("C", _ => _.Field("X"))
                           .Field("D", _ => _.Field("X"))
                           .Field("E", _ => _.Field("X"))
                           .Field("F")
                           .Field("G")
                           .Field("H")
                           .Field("I")
                           .Field("J")
                           .Field("K", _ => _
                                  .Field("W")
                                  .Field("Z", __ => __.Field("X"))
                                  )
                           .Create();

            actual.ShouldBeEquivalentTo(expected);
        }
        public FormatterBenchmark()
        {
            responseSpecification = ResponseSpecification.Create <ClientUserAccount>();

            random = new Random();
            partialResponseFormatter = new PartialResponseFormatter();
            serverModel = new ServerUserAccount
            {
                UserId            = Guid.NewGuid(),
                UserName          = GenString(20),
                LastVisitTime     = DateTime.Today,
                UserEmail         = GenString(30),
                ContactPhone      = Enumerable.Range(0, 5).Select(i => GenPhone()).ToArray(),
                CreditCards       = Enumerable.Range(0, 3).Select(i => GenCreditCard()).ToArray(),
                PreviousPurchases = Enumerable.Range(0, 10).Select(i => GenPreviousPurchase()).ToArray(),
                UserBag           = new ServerUserBag
                {
                    ValidUntil = DateTime.Now,
                    PromoCode  = GenString(6),
                    Items      = Enumerable.Range(0, 10).Select(i => Guid.NewGuid()).ToDictionary(i => i, i => GenBagItem())
                }
            };
        }
 public void Test_Cyclic_Dependency()
 {
     Assert.Throws <InvalidOperationException>(() => ResponseSpecification.Create <CyclicDependencyRoot>());
 }
 public void Test_Duplicate_Field_Names_When_Implicit_Specification_Building()
 {
     Assert.Throws <InvalidOperationException>(() => ResponseSpecification.Create <ClassWithDuplicateFieldName>());
 }
        public void Test_Contract_With_Ignored_Properties()
        {
            var actual = ResponseSpecification.Create <IgnoredPropertiesClass>();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Field("A").Create());
        }
        public void Test_Create_For_Simple_Type()
        {
            var actual = ResponseSpecification.Create <SimpleType>();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Field("A").Create());
        }
        public void Test_Array_Of_Array_Of_Nested_Types()
        {
            var actual = ResponseSpecification.Create <NestedType[][]>();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Field("X").Create());
        }
        public void Test_Array_Of_Int()
        {
            var actual = ResponseSpecification.Create <int[]>();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Empty);
        }
        public void Test_Dictionary_Of_Dictionary_Of_Nested_Types()
        {
            var actual = ResponseSpecification.Create <Dictionary <Guid, Dictionary <string, NestedType> > >();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Field("X").Create());
        }
        public void Test_Dictionary_Of_Guids()
        {
            var actual = ResponseSpecification.Create <Dictionary <Guid, Guid> >();

            actual.ShouldBeEquivalentTo(ResponseSpecification.Empty);
        }