Merge pull request #30 from catcherwong/dtmcommon

DtmCommon And Return value

src/Dtmcli.Tests/BranchBarrierTests.cs

@@ -9,7 +9,7 @@
 using Microsoft.Extensions.Primitives;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.DependencyInjection;
-using Dtmcli.DtmImp;
+using DtmCommon;
 
 namespace Dtmcli.Tests
 {
@@ -57,7 +57,7 @@ public void CreateBranchBarrier_FromQs_Should_ThrowException()
 
  var qs = new Microsoft.AspNetCore.Http.QueryCollection(dict);
 
- Assert.Throws<DtmcliException>(() => _factory.CreateBranchBarrier(qs));
+ Assert.Throws<DtmException>(() => _factory.CreateBranchBarrier(qs));
  }
 #endif
 
@@ -162,20 +162,20 @@ public async void Call_Should_Throw_Duplicated_Exception_When_QueryPrepared_At_F
 
  var connQ = GetDbConnection();
  connQ.Mocks.When(cmd => cmd.CommandText.Contains("insert", StringComparison.Ordinal)).ReturnsScalar(cmd => 1);
- connQ.Mocks.When(cmd => cmd.CommandText.Contains("select", StringComparison.OrdinalIgnoreCase)).ReturnsScalar(cmd => Constant.Barrier.MSG_BARRIER_REASON);
+ connQ.Mocks.When(cmd => cmd.CommandText.Contains("select", StringComparison.OrdinalIgnoreCase)).ReturnsScalar(cmd => DtmCommon.Constant.Barrier.MSG_BARRIER_REASON);
 
  // QueryPrepared at first
  var qRes = await branchBarrier.QueryPrepared(connQ);
- Assert.Equal(Constant.ErrFailure, qRes);
+ Assert.Equal(DtmCommon.Constant.ResultFailure, qRes);
 
  var connC = GetDbConnection();
  connC.Mocks.When(cmd => cmd.Parameters.AsList().Select(x => x.Value).Contains("msg")).ReturnsScalar(cmd => 0);
 
  var mockBusiCall = new Mock<Func<System.Data.Common.DbTransaction, Task<bool>>>();
 
  // Call later
- var ex = await Assert.ThrowsAsync<DtmcliException>(async () => await branchBarrier.Call(connC, mockBusiCall.Object));
- Assert.Equal(Constant.ResultDuplicated, ex.Message);
+ var ex = await Assert.ThrowsAsync<DtmDuplicatedException>(async () => await branchBarrier.Call(connC, mockBusiCall.Object));
+ Assert.Equal(DtmCommon.Constant.ResultDuplicated, ex.Message);
  mockBusiCall.Verify(x => x.Invoke(It.IsAny<System.Data.Common.DbTransaction>()), Times.Never);
  }
  }

src/Dtmcli.Tests/BranchIDGenTests.cs

@@ -1,4 +1,4 @@
-using Dtmcli.DtmImp;
+using DtmCommon;
 using System;
 using Xunit;
 

src/Dtmcli.Tests/DbSpecialTests.cs

@@ -1,4 +1,4 @@
-using Dtmcli.DtmImp;
+using DtmCommon;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
@@ -42,15 +42,15 @@ public void Test_MsSQL_DbSpecial()
 
  Assert.IsType<SqlServerDBSpecial>(special);
  Assert.Equal("insert into a(f) values(@f)", special.GetInsertIgnoreTemplate("a(f) values(@f)", "c"));
- Assert.Throws<DtmcliException>(() => special.GetXaSQL("", ""));
+ Assert.Throws<DtmException>(() => special.GetXaSQL("", ""));
  }
 
  [Fact]
  public void Test_Other_DbSpecial()
  {
  var provider = TestHelper.AddDtmCli(db: "other");
 
- var ex = Assert.Throws<DtmcliException>(() => provider.GetRequiredService<DbSpecialDelegate>());
+ var ex = Assert.Throws<DtmException>(() => provider.GetRequiredService<DbSpecialDelegate>());
  Assert.Equal("unknown db type 'other'", ex.Message);
  }
  }

src/Dtmcli.Tests/MsgTests.cs

@@ -1,4 +1,5 @@
 using Apps72.Dev.Data.DbMocker;
+using DtmCommon;
 using Microsoft.Extensions.DependencyInjection;
 using Moq;
 using System;
@@ -53,18 +54,17 @@ public async void Submit_Should_Succeed()
  { "bh2", "456" },
  });
 
- var prepareRes = await msg.Prepare(busi + "/query");
- Assert.True(prepareRes);
+ await msg.Prepare(busi + "/query");
+ await msg.Submit();
 
- var submitRes = await msg.Submit();
- Assert.True(submitRes);
+ Assert.True(true);
  }
 
  [Fact]
  public async void DoAndSubmitDB_Should_Throw_Exception_When_Transbase_InValid()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
 
  var gid = string.Empty;
  var msg = new Msg(dtmClient.Object, _branchBarrierFactory, gid);
@@ -75,14 +75,14 @@ public async void DoAndSubmitDB_Should_Throw_Exception_When_Transbase_InValid()
 
  var db = new MockDbConnection();
 
- await Assert.ThrowsAsync<DtmcliException>(async () => await msg.DoAndSubmitDB(busi + "/query", db, x => Task.FromResult<bool>(true)));
+ await Assert.ThrowsAsync<DtmException>(async () => await msg.DoAndSubmitDB(busi + "/query", db, x => Task.FromResult<bool>(true)));
  }
 
  [Fact]
  public async void DoAndSubmitDB_Should_Not_Call_Barrier_When_Prepare_Fail()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
 
  var gid = "TestMsgNormal";
  var msg = new Msg(dtmClient.Object, _branchBarrierFactory, gid);
@@ -94,18 +94,16 @@ public async void DoAndSubmitDB_Should_Not_Call_Barrier_When_Prepare_Fail()
  var db = new MockDbConnection();
  var mockBusiCall = new Mock<Func<DbTransaction, Task<bool>>>();
 
- var res = await msg.DoAndSubmitDB(busi + "/query", db, x => Task.FromResult(true));
-
- Assert.False(res);
+ await Assert.ThrowsAnyAsync<Exception>(async () => await msg.DoAndSubmitDB(busi + "/query", db, x => Task.FromResult(true))); 
  mockBusiCall.Verify(x => x.Invoke(It.IsAny<DbTransaction>()), Times.Never);
  }
 
  [Fact]
  public async void DoAndSubmitDB_Should_Succeed()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_SUBMIT, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_SUBMIT, false);
 
  var gid = "TestMsgNormal";
  var msg = new Msg(dtmClient.Object, _branchBarrierFactory, gid);
@@ -121,18 +119,17 @@ public async void DoAndSubmitDB_Should_Succeed()
  var mockBusiCall = new Mock<Func<DbTransaction, Task<bool>>>();
  mockBusiCall.Setup(x => x.Invoke(It.IsAny<DbTransaction>())).Returns(Task.FromResult(true));
 
- var res = await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object);
+ await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object);
 
- Assert.True(res);
  mockBusiCall.Verify(x => x.Invoke(It.IsAny<DbTransaction>()), Times.Once);
  }
 
  [Fact]
  public async void DoAndSubmitDB_Should_Abort_When_BusiCall_ThrowExeption_With_ResultFailure()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, false);
 
  var gid = "TestMsgNormal";
  var msg = new Msg(dtmClient.Object, _branchBarrierFactory, gid);
@@ -146,21 +143,19 @@ public async void DoAndSubmitDB_Should_Abort_When_BusiCall_ThrowExeption_With_Re
  db.Mocks.When(x => x.CommandText.Contains("select", StringComparison.OrdinalIgnoreCase)).ReturnsScalar(cmd => "rollback");
 
  var mockBusiCall = new Mock<Func<DbTransaction, Task>>();
- mockBusiCall.Setup(x => x.Invoke(It.IsAny<DbTransaction>())).Throws(new Exception(Constant.ResultFailure));
-
- var res = await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object);
+ mockBusiCall.Setup(x => x.Invoke(It.IsAny<DbTransaction>())).Throws(new DtmFailureException());
 
- Assert.False(res);
- dtmClient.Verify(x => x.TransCallDtm(It.IsAny<DtmImp.TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
+ await Assert.ThrowsAsync<DtmFailureException>(async () => await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object));
+ dtmClient.Verify(x => x.TransCallDtm(It.IsAny<TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
  }
 
  [Fact]
  public async void DoAndSubmitDB_Should_QueryPrepared_When_BusiCall_ThrowExeption_Without_ResultFailure()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_SUBMIT, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_SUBMIT, false);
  TestHelper.MockTransRequestBranch(dtmClient, System.Net.HttpStatusCode.OK);
 
  var gid = "TestMsgNormal";
@@ -177,10 +172,8 @@ public async void DoAndSubmitDB_Should_QueryPrepared_When_BusiCall_ThrowExeption
  var mockBusiCall = new Mock<Func<DbTransaction, Task<bool>>>();
  mockBusiCall.Setup(x => x.Invoke(It.IsAny<DbTransaction>())).Throws(new Exception("ex"));
 
- var res = await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object);
-
- Assert.False(res);
- dtmClient.Verify(x => x.TransRequestBranch(It.IsAny<DtmImp.TransBase>(), It.IsAny<HttpMethod>(), It.IsAny<object>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Once);
+ await Assert.ThrowsAsync<Exception>(async () => await msg.DoAndSubmitDB(busi + "/query", db, mockBusiCall.Object));
+ dtmClient.Verify(x => x.TransRequestBranch(It.IsAny<TransBase>(), It.IsAny<HttpMethod>(), It.IsAny<object>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Once);
  }
 
  public class MsgMockHttpMessageHandler : DelegatingHandler
@@ -193,7 +186,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
  {
  var str = await request.Content?.ReadAsStringAsync() ?? "";
 
- var transBase = System.Text.Json.JsonSerializer.Deserialize<DtmImp.TransBase>(str);
+ var transBase = System.Text.Json.JsonSerializer.Deserialize<TransBase>(str);
 
  Assert.Equal("TestMsgNormal", transBase.Gid);
  Assert.Equal("msg", transBase.TransType);

src/Dtmcli.Tests/SagaTests.cs

@@ -1,4 +1,6 @@
-using Moq;
+using DtmCommon;
+using Moq;
+using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
@@ -47,6 +49,24 @@ public async void Submit_Should_Succeed()
  await sage.Submit();
  }
 
+ [Fact]
+ public async void Submit_Should_ThrowException()
+ {
+ var dtmClient = new Mock<IDtmClient>();
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_SUBMIT, true);
+
+ var gid = "TestSagaNormal";
+ var saga = new Saga(dtmClient.Object, gid);
+
+ var busi = "http://localhost:8081/api/busi";
+ var req = new { Amount = 30 };
+
+ saga.Add(string.Concat(busi, "/TransOut"), string.Concat(busi, "/TransOutRevert"), req)
+ .Add(string.Concat(busi, "/TransIn"), string.Concat(busi, "/TransInRevert"), req);
+
+ await Assert.ThrowsAnyAsync<Exception>(async () => await saga.Submit());
+ }
+
  public class SageMockHttpMessageHandler : DelegatingHandler
  {
  public SageMockHttpMessageHandler()
@@ -57,7 +77,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
  {
  var str = await request.Content?.ReadAsStringAsync() ?? "";
 
- var transBase = System.Text.Json.JsonSerializer.Deserialize<DtmImp.TransBase>(str);
+ var transBase = System.Text.Json.JsonSerializer.Deserialize<TransBase>(str);
 
  /*
 {

src/Dtmcli.Tests/ServiceCollectionExtensionsTests.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Configuration;
+using DtmCommon;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using System.Collections.Generic;

src/Dtmcli.Tests/TccTests.cs

@@ -2,6 +2,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using DtmCommon;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
@@ -14,8 +15,8 @@ public class TccTests
  public async void Execute_Should_Submit()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, false);
  TestHelper.MockTransRequestBranch(dtmClient, System.Net.HttpStatusCode.OK);
 
  var gid = "tcc_gid";
@@ -33,9 +34,9 @@ public async void Execute_Should_Submit()
  public async void Execute_Should_Abort_When_CallBranch_With_Old_Ver_Exception()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, true);
- TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, false);
+ TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, false);
  TestHelper.MockTransRequestBranch(dtmClient, System.Net.HttpStatusCode.OK, "FAILURE");
 
  var gid = "tcc_gid";
@@ -47,16 +48,16 @@ public async void Execute_Should_Abort_When_CallBranch_With_Old_Ver_Exception()
  });
 
  Assert.Empty(res);
- dtmClient.Verify(x => x.TransCallDtm(It.IsAny<DtmImp.TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
+ dtmClient.Verify(x => x.TransCallDtm(It.IsAny<TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
  }
 
  [Fact]
  public async void Execute_Should_Abort_When_CallBranch_With_New_Ver_Exception()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, true);
- TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_ABORT, false);
+ TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, false);
  TestHelper.MockTransRequestBranch(dtmClient, System.Net.HttpStatusCode.BadRequest);
 
  var gid = "tcc_gid";
@@ -68,15 +69,15 @@ public async void Execute_Should_Abort_When_CallBranch_With_New_Ver_Exception()
  });
 
  Assert.Empty(res);
- dtmClient.Verify(x => x.TransCallDtm(It.IsAny<DtmImp.TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
+ dtmClient.Verify(x => x.TransCallDtm(It.IsAny<TransBase>(), It.IsAny<object>(), Constant.Request.OPERATION_ABORT, It.IsAny<CancellationToken>()), Times.Once);
  }
 
  [Fact]
  public async void Set_TransOptions_Should_Succeed()
  {
  var dtmClient = new Mock<IDtmClient>();
- TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, true);
- TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, true);
+ TestHelper.MockTransCallDtm(dtmClient, Constant.Request.OPERATION_PREPARE, false);
+ TestHelper.MockTransRegisterBranch(dtmClient, Constant.Request.OPERATION_REGISTERBRANCH, false);
  TestHelper.MockTransRequestBranch(dtmClient, System.Net.HttpStatusCode.OK);
 
  var gid = "tcc_gid";