using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Net;

using System.Threading.Tasks;

​

using RestSharp.Deserializers;

using RestSharp.Extensions;

using RestSharp;

using RestSharp.Serializers;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

using Moq;

​

//https://stackoverflow.com/questions/53027545/rest-sharp-deserialize-partial-object

​

using Coinbase.Serialization;

​

    public static class RestSharpExtensions

    {

        static T DeserializeAnonymousType<T>(this IDeserializer deserializer, IRestResponse response, T anonymousTypeObject)

        {

            if (deserializer == null)

                throw new ArgumentNullException();          

            return deserializer.Deserialize<T>(response);

        }

    }

​

    public class Balance // FIXED spelling

    {

        public Double Amount { get; set; }

        //public Currency Currency { get; set; }

    }

​

    public class Account

    {

        public string Id { get; set; }

        public string Name { get; set; }

        public bool Primary { get; set; }

        public string /* AccountType */ Type { get; set; }

        public Balance Balance { get; set; } // FIXED spelling

        public DateTime CreatedAt { get; set; }

    }

​

    class TestClass

    {

        public static IRestClient MockRestClient<T>(HttpStatusCode httpStatusCode, string json) 

            where T : new() 

        {

            var data = JsonConvert.DeserializeObject<T>(json);

            var response =  new Mock<IRestResponse<T>>();

            response.Setup(_ => _.StatusCode).Returns(httpStatusCode);

            response.Setup(_ => _.Data).Returns(data);

​

            var mockIRestClient = new Mock<IRestClient>();

​

            mockIRestClient

              .Setup(x => x.Execute<T>(It.IsAny<IRestRequest>()))

              .ReturnsAsync(response.Object);

​

            return mockIRestClient.Object;

        }

        public static void Test()

        {

            var response = new RestResponse

            {

                Content = GetJson(),

                ContentType = "application/json",

            };

            var JsonSettings = new JsonSerializerSettings

            {

                ContractResolver = new DefaultContractResolver { NamingStrategy = new SnakeCaseNamingStrategy() },

            };

            var jsonDeserializer = new JsonNetDeseralizer(JsonSettings);

        }

        static string GetJson()

        {

            var json = @"{

   ""pagination"":{

      ""ending_before"":null

   },

   ""data"":[

      {

         ""id"":""gje99c1e-7081-5784-9a1e-4p302b92312b"",

         ""name"":""ETH Wallet"",

         ""primary"":false,

         ""type"":""wallet"",

         ""balance"":{

            ""amount"":""0.97845347"",

            ""currency"":""ETH""

         },

         ""created_at"":""2017-10-01T16:50:51Z"",

         ""resource"":""account""

      }

   ]

}";

            return json;

        }

    }

​

    namespace Coinbase.Serialization

    {

        //https://github.com/bchavez/Coinbase/blob/master/Source/Coinbase/Serialization/JsonNetDeseralizer.cs

       public class JsonNetDeseralizer : IDeserializer

       {

          private readonly JsonSerializerSettings settings;

​

          public JsonNetDeseralizer(JsonSerializerSettings settings)

          {

             this.settings = settings;

          }

​

          public T Deserialize<T>(IRestResponse response)

          {

             return JsonConvert.DeserializeObject<T>(response.Content, settings);

          }

​

          public string RootElement { get; set; }

          public string Namespace { get; set; }

          public string DateFormat { get; set; }

       }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            //Console.WriteLine("Json.NET version: " + typeof(Newtonsoft.Json.JsonSerializer).Assembly.FullName);

            Console.WriteLine("RestSharp version: " + typeof(RestResponse).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

​