[Fact]
public void Case6_Query_Error_Result()
{
    _configService.GetAppSetting("pickup.service.url")
        .Returns(UrlMockResultError);
    _storeSettingService.GetValue(_testStoreId, "pickup.service", "loginId").Returns("testId");
    _storeSettingService.GetValue(_testStoreId, "pickup.service", "auth").Returns("testAuth");
    target = new PickupService(_configService, _storeSettingService);

    Action act = () => target.GetUpdateStatus(_testStoreId, _testWaybillNo);
    act.Should().Throw<Exception>();
}

if (obj.result == "error")
{
    throw new Exception();
}

[Fact]
public void Case7_Query_Error_Result_Should_LogError()
{
    GetPickupServiceWith(UrlMockResultError);
    target.GetUpdateStatus(_testStoreId, _testWaybillNo);
    _logger.Received().LogError(Arg.Any<string>());
}

[Fact]
public void Case6_Query_Error_Result()
{
    GetPickupServiceWith(UrlMockResultError);
    Action act = () => target.GetUpdateStatus(_testStoreId, _testWaybillNo);
    act.Should().Throw<Exception>();
    _logger.ReceivedWithAnyArgs().LogError(default(string));
}

-   public PickupService(IConfigService configService, IStoreSettingService storeSettingService)
+   public PickupService(IConfigService configService, IStoreSettingService storeSettingService, ILogger logger)
    {
        this._configService = configService;
        this._storeSettingService = storeSettingService;
+       this._logger = logger;
    }

    if (obj.result == "error")
    {
+       this._logger.LogError(obj.result);
        throw new Exception();
    }

[Fact]
public void Case7_Query_Error_Content()
{
     GetPickupServiceWith(UrlMockContentError);
     var actual = target.GetUpdateStatus(_testStoreId, _testWaybillNo);
     actual.Should().BeEmpty();
}

+    if (string.IsNullOrEmpty(c.ErrorCode))
+    {
        switch (c.Status)
        {
            ////略…
        }
+    }

[Fact]
public void Case8_Query_Exception()
{
    GetPickupServiceWith(UrlMockException);
    Action act = () => target.GetUpdateStatus(_testStoreId, _testWaybillNo);
    act.Should().Throw<Exception>();
    _logger.ReceivedWithAnyArgs().LogError(default(string));
}

ILogger logger = Substitute.For<ILogger>();
IStoreSettingService storeSettingService = Substitute.For<IStoreSettingService>();
storeSettingService.GetValue(Arg.Any<long>(), "pickup.service", "auth").Returns("FakeAuth");
IConfigService configService = Substitute.For<IConfigService>();
configService.GetAppSetting("pickup.service.url").Returns("https://test.com/");

var target = new PickupService(configService, storeSettingService, logger);

var actual = target.GetUpdateStatus(2, new List<string> {"TestWayBillNo"});
actual.Should().BeEquivalentTo(new List<ShippingOrderUpdateEntity>
{
    new ShippingOrderUpdateEntity
    {
        AcceptTime = new DateTime(2020, 03, 03, 17, 51, 20),
        OuterCode = "TestWayBillNo",
        Status = StatusEnum.Finish
    }
});

+       internal HttpClient HttpClient;
        private const string DeliveryOrder = "DeliveryOrder";

        try
        {
            var result = new List<ShippingOrderUpdateEntity>();
-           var httpClient = new HttpClient();
+           this.HttpClient?? = new HttpClient();

+       [assembly: InternalsVisibleTo("Marsen.NetCore.Dojo.Tests")]
        namespace Marsen.NetCore.Dojo.Kata_PickupService

target.HttpClient =
    new HttpClient(
    new MockHttpMessageHandler(JsonSerializer.Serialize(
    new ResponseEntity
    {
        Result = "",
        Content = new List<Content>
        {
            new Content
            {
                ErrorCode = string.Empty,
                Status = Status.DONE,
                lastStatusDate = "2020-03-03",
                lastStatusTime = "17:51:20"
            }
        }
    }),
HttpStatusCode.OK));

[Fact]
public void Case1_Just_Run()
{
    var target = new PickupService();
    long storeId = 0;
    List<string> waybillNo = new List<string>();
    target.GetUpdateStatus(storeId, waybillNo);
}

-            //// TODO 1.建立 HttpClient
+            var httpClient = new HttpClient();

-           //// TODO 2.建立 auth
+           //// TODO login id 抽參數
+           httpClient.DefaultRequestHeaders.Add("login_id", "testId");
+           //// TODO authorization 抽參數
+           httpClient.DefaultRequestHeaders.Add("authorization", "testAuth");

-           //// TODO 3.準備 HttpContent 資料

+           var requestContent = JsonSerializer.Serialize(new { Type = "DeliveryOrder", waybillNo });
+           var httpContent = new StringContent(requestContent, Encoding.UTF8, "application/json");

//// TODO 4.指定 API URL
string url=string.Empty;
var responseMessage = httpClient.PostAsync(url, httpContent).Result;

+ //// TODO Parse Response Entity
+ //// TODO Switch Status
+ //// TODO Return ShippingOrderUpdateEntity List

[Fact]
public void Case1_Query_Done_waybillNo()
{
    var target = new PickupService();
    long storeId = 1;
    List<string> waybillNo = new List<string> {"TEST2002181800010"};
    var actual = target.GetUpdateStatus(storeId, waybillNo).FirstOrDefault().Status;
    actual.Should().Be(StatusEnum.Finish);
}

-        //// TODO url 抽參數
-        //// string url= "http://www.mocky.io/v2/********";
-        string url = "http://www.mocky.io/v2/********";
+        string url = this._configService.GetAppSetting("pickup.service.url");

var configService = Substitute.For<IConfigService>();
configService.GetAppSetting("pickup.service.url")
        .Returns("http://www.mocky.io/v2/********");
var target = new PickupService(configService);

[Fact]
public void Case1_Query_Done_waybillNo()
{
    var actual = QueryWithDoneWaybillNo();
    actual.Should().Be(StatusEnum.Finish);
}

[Fact]
public void Case2_Query_Shipping_waybillNo()
{
    var actual = QueryWithShippingWaybillNo();
    actual.Should().Be(StatusEnum.Processing);
}

-           //// TODO Switch Status
-           //// TODO Return ShippingOrderUpdateEntity List
-           result.Add(new ShippingOrderUpdateEntity {Status = StatusEnum.Finish});
+           foreach (var c in obj.content)
+           {
+               switch (c.lastStatusId)
+               {
+                   case "DONE":
+                       result.Add(new ShippingOrderUpdateEntity {Status = StatusEnum.Finish});
+                       break;
+                   case "Shipping":
+                       result.Add(new ShippingOrderUpdateEntity {Status = StatusEnum.Processing});
+                       break;
+               }
+           }

[Fact]
public void Case2_Query_Shipping_waybillNo()
{
    var actual = QueryWaybillNoWith(UrlMockShipping);
    actual.Should().Be(StatusEnum.Processing);
}

-           //// TODO login id 抽參數
-           httpClient.DefaultRequestHeaders.Add("login_id", "testId");

+           var loginId = this._storeSettingService.GetValue(storeId,"pickup.service","loginId");
+           httpClient.DefaultRequestHeaders.Add("login_id", loginId);

_storeSettingService.GetValue(_testStoreId, "pickup.service", "loginId").Returns("testId");

-           //// TODO authorization 抽參數
-           httpClient.DefaultRequestHeaders.Add("authorization", "testAuth");
+           var auth = this._storeSettingService.GetValue(storeId,"pickup.service","auth");
+           httpClient.DefaultRequestHeaders.Add("authorization", auth);

_storeSettingService.GetValue(_testStoreId, "pickup.service", "auth").Returns("testAuth");

[Fact]
public void pay_should_Get_requestId()
{
    var target = new PaymentService();
    target.Pay();
    httpClient.Received().GetAsync("https://testing.url/api/v1/requestId");
}

public interface IHttpClient
{

}

public interface IHttpClient
{
    Task<HttpResponseMessage> GetAsync(string requestUri);
}
public class HttpClientProxy : IHttpClient
{
    public Task<HttpResponseMessage> GetAsync(string requestUri)
    {
        return new HttpClient().GetAsync(requestUri);
    }
}

[Fact]
public void pay_should_Get_requestId()
{
    IHttpClient httpClient = Substitute.For<IHttpClient>();
    var target = new PaymentService(httpClient);
    target.Pay();
    httpClient.Received().GetAsync("https://testing.url/api/v1/requestId");
}

public class PaymentService
{
    private readonly IHttpClient _httpClient;
    public PaymentService(IHttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public void Pay()
    {
        _httpClient.GetAsync("https://testing.url/api/v1/requestId");
    }
}

[Fact]
public void pay_should_Post_Pay_CreditCard()
{
    IHttpClient httpClient = Substitute.For<IHttpClient>();
    var target = new PaymentService(httpClient);
    target.Pay();
    this._httpClient.Received().PostAsync("https://testing.url/api/v1/pay/CreditCard", Arg.Any<HttpContent>());
}

public void Pay()
{
    var readAsStringAsync = this._httpClient.GetAsync("https://testing.url/api/v1/requestId");

    this._httpClient.PostAsync("https://testing.url/api/v1/pay/CreditCard", null);
}

[Fact]
public void pay_should_Get_requestId()
{
    WhenPay();
    ShouldGetRequestId();
}

[Fact]
public void pay_should_Post_Pay_CreditCard()
{
    WhenPay();
    ShouldPayByCreditCard();
}

private void WhenPay()
{
    var target = new PaymentService(_httpClient);
    target.Pay();
}

private void ShouldGetRequestId()
{
    this._httpClient.Received(1).GetAsync($"{_testingApiUrl}requestId");
}

private void ShouldPayByCreditCard()
{
    this._httpClient.Received(1).PostAsync($"{_testingApiUrl}pay/CreditCard",
        Arg.Any<HttpContent>()));
}

[Fact]
public void pay_should_Get_RequestId_Before_Post_Pay_CreditCard()
{
    WhenPay();
    Received.InOrder(() =>
    {
        ShouldGetRequestId();
        ShouldPayByCreditCard();
    });
}

private void ShouldPayByCreditCard()
{
    this._httpClient.Received(1).PostAsync($"{_testingApiUrl}pay/CreditCard",
    Arg.Is<HttpContent>(x => x.ReadAsStringAsync().Result.Contains(_testRequestId)));
}

public void Pay()
{
    var requestId = this._httpClient.GetAsync("https://testing.url/api/v1/requestId").Result.Content
        .ReadAsStringAsync().Result;
    HttpContent content = new StringContent(
    JsonSerializer.Serialize(
        new PayEntity
        {
            RequestId = requestId
        }));

    this._httpClient.PostAsync("https://testing.url/api/v1/pay/CreditCard", content);
}

public class PayEntity
{
    public string RequestId { get; set; }
}

private void WhenPay()
{
    var target = new PaymentService(_httpClient);
    target.Pay(new PayEntity());
}

public void Pay(PayEntity payEntity)
{
     var requestId = this._httpClient.GetAsync("https://testing.url/api/v1/requestId").Result.Content
         .ReadAsStringAsync().Result;
     HttpContent content = new StringContent(
         JsonSerializer.Serialize(
             payEntity.RequestId = requestId));
      this._httpClient.PostAsync("https://testing.url/api/v1/pay/CreditCard", content);
}

public PaymentServiceTests()
{
    this._httpClient = Substitute.For<IHttpClient>();
    this._httpClient.GetAsync(Arg.Any<string>()).ReturnsForAnyArgs(
        Task.FromResult(
            new HttpResponseMessage
            {
                Content = new StringContent(_testRequestId)
            }));
    this._configure = Substitute.For<IConfigure>();
    this._configure.Setting("PayService.Url").Returns(_testingApiUrl);
}

public PaymentService(IHttpClient httpClient, IConfigure configure)
{
    this._httpClient = httpClient;
    this._configure = configure;
}

public void Pay(PayEntity payEntity)
{
    var apiUrl = this._configure.Setting("PayService.Url");
    var requestId = this._httpClient.GetAsync($"{apiUrl}requestId").Result.Content
        .ReadAsStringAsync().Result;
    HttpContent content = new StringContent(
        JsonSerializer.Serialize(
        payEntity.RequestId = requestId));

        this._httpClient.PostAsync($"{apiUrl}pay/CreditCard", content);
}

new PersonEntity {
    Name = "Tian Tank"
    Age = 30
}

[Fact]
public void CovertName()
{
    ////Arrange

    ////Act
    var actual = _target.Parse(testJson).Name;
    ////Assert
    actual.Should().BeEquivalentTo("Tian Tank");
}

public PersonaEntity Parse(string json)
{
    return new PersonaEntity
    {
        Name = "Tian Tank"
    };
}

public class PersonaEntity
{
    public string Name { get; set; }
}

public PersonaEntity Parse(string json)
{
    return new PersonaEntity
    {
        Name = "Tian" + "Tank"
    };
}

public PersonaEntity Parse(string json)
{
    return new PersonaEntity
    {
        Name = "Tian" +" "+ "Tank"
    };
}

public PersonaEntity Parse(string json)
{
    var firstName = "Tian";
    var lastName = "Tank";
    return new PersonaEntity
    {
        Name = firstName + " " + lastName
    };
}

public PersonaEntity Parse(string json)
{
    var firstName = "Tian";
    var lastName = "Tank";
    var originEntity = new PersonaOriginEntity
    {
        FirstName = firstName,
        LastName = lastName
    };
    return new PersonaEntity
    {
        Name = $"{originEntity.FirstName} {originEntity.LastName}"
    };
}

public class PersonaOriginEntity
{
    public string LastName { get; set; }
    public string FirstName { get; set; }
}

public PersonaEntity Parse(string json)
{
    var originEntity = new PersonaOriginEntity
    {
        FirstName = "Tian",
        LastName = "Tank"
    };

    return new PersonaEntity
    {
        Name = $"{originEntity.FirstName} {originEntity.LastName}"
    };
}

public PersonaEntity Parse(string json)
{
   //var originEntity = new PersonaOriginEntity
   //{
   //    FirstName = "Tian",
   //    LastName = "Tank"
   //};
   var originEntity = JsonSerializer.Deserialize<PersonaOriginEntity>(json);

   return new PersonaEntity
   {
       Name = $"{originEntity.FirstName} {originEntity.LastName}"
   };
}

public PersonaEntity Parse(string json)
{
   //var originEntity = new PersonaOriginEntity
   //{
   //    FirstName = "Tian",
   //    LastName = "Tank"
   //};
   var originEntity = JsonSerializer.Deserialize<PersonaOriginEntity>(json);

   return new PersonaEntity
   {
       Name = $"{originEntity.FirstName} {originEntity.LastName}"
   };
}

[Fact]
public void CovertAge()
{
    ////Arrange
    ////Act
    var actual = _target.Parse(testJson).Age;
    ////Assert
    actual.Should().Be(30);
}

public class PersonaEntity
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public PersonaEntity Parse(string json)
{
    var originEntity = JsonSerializer.Deserialize<PersonaOriginEntity>(json);

    return new PersonaEntity
    {
        Name = $"{originEntity.FirstName} {originEntity.LastName}",
        Age = 30
    };
}

public PersonaEntity Parse(string json)
{
    var originEntity = JsonSerializer.Deserialize<PersonaOriginEntity>(json);

    return new PersonaEntity
    {
        Name = $"{originEntity.FirstName} {originEntity.LastName}",
        Age = originEntity.BirthDate.Year - DateTime.Now.Year
    };
}

public struct SystemDateTime
{
    private static DateTime? _mockDateTime = null;

    public static DateTime Now
    {
        get => _mockDateTime ?? DateTime.Now;
        internal set => _mockDateTime = value;
    }

    internal static void Reset()
    {
        _mockDateTime = null;
    }
}

[Fact]
public void CovertAgeTodayIs2019()
{
    ////Arrange
    SystemDateTime.Now = Convert.ToDateTime("2019/12/28");
    ////Act
    var actual = _target.Parse(testJson).Age;
    ////Assert
    actual.Should().Be(30);
}

[Fact]
public void CovertAgeTodayIs2020()
{
    ////Arrange
    SystemDateTime.Now = Convert.ToDateTime("2020/12/28");
    ////Act
    var actual = _target.Parse(testJson).Age;
    ////Assert
    actual.Should().Be(31);
        }

[Fact]
public void parse_name()
{
    AfterParseJson().Name.Should().Be("Tian Tank");
}

[Fact]
public void parse_age_today_is_2019()
{
    GiveTodayIs("2019/12/28").Age.Should().Be(30);
}

[Fact]
public void parse_age_today_is_2030()
{
    GiveTodayIs("2030/05/06").Age.Should().Be(41);
}