public void Test_GetDisputesForUser()
{
ListPaginated <DisputeDTO> result = null;
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.DisputeType.HasValue && x.DisputeType.Value == DisputeType.NOT_CONTESTABLE);
if (dispute == null)
{
Assert.Fail("Cannot test getting disputes for user because there's no not contestable disputes in the disputes list.");
}
try
{
string userId = Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null)[0].AuthorId;
result = Api.Disputes.GetDisputesForUser(userId, new Pagination(1, 20), null);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
}
public async Task Test_Refund_GetRefundsForRepudiation()
{
try
{
Sort sort = new Sort();
sort.AddField("CreationDate", SortDirection.desc);
var _clientDisputes = await Api.Disputes.GetAll(new Pagination(1, 100), null, sort);
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.InitialTransactionId != null && x.DisputeType.HasValue && x.DisputeType.Value == DisputeType.NOT_CONTESTABLE);
var temp = await Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null);
string repudiationId = temp[0].Id;
var pagination = new Pagination(1, 1);
var filter = new FilterRefunds();
var refunds = Api.Refunds.GetRefundsForRepudiation(repudiationId, pagination, filter, sort);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public async Task Test_GetDocumentConsultations()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
if (dispute == null)
{
Assert.Fail("Cannot test creating dispute document page because there's no dispute with expected status in the disputes list.");
}
try
{
DisputeDocumentPostDTO documentPost = new DisputeDocumentPostDTO(DisputeDocumentType.DELIVERY_PROOF);
var disputeDocument = await Api.Disputes.CreateDisputeDocument(documentPost, dispute.Id);
Assembly assembly = Assembly.GetExecutingAssembly();
FileInfo assemblyFileInfo = new FileInfo(assembly.Location);
FileInfo fi = assemblyFileInfo.Directory.GetFiles("TestKycPageFile.png").Single();
byte[] bytes = File.ReadAllBytes(fi.FullName);
await Api.Disputes.CreateDisputePage(dispute.Id, disputeDocument.Id, bytes);
var result = await Api.Disputes.GetDocumentConsultations(disputeDocument.Id);
Assert.AreEqual(1, result.Count);
Assert.IsInstanceOf <DateTime>(result.First().ExpirationDate);
Assert.IsInstanceOf <String>(result.First().Url);
Assert.IsNotEmpty(result.First().Url);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void Test_ContestDispute()
{
DisputeDTO notContestedDispute = _clientDisputes.FirstOrDefault(x => (x.DisputeType == DisputeType.CONTESTABLE || x.DisputeType == DisputeType.RETRIEVAL) &&
(x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION));
if (notContestedDispute == null)
{
Assert.Fail("Cannot test contesting dispute because there's no disputes that can be contested in the disputes list.");
}
DisputeDTO result = null;
try
{
Money contestedFunds = notContestedDispute.Status == DisputeStatus.PENDING_CLIENT_ACTION ? new Money {
Amount = 100, Currency = CurrencyIso.EUR
} : null;
result = Api.Disputes.ContestDispute(contestedFunds, notContestedDispute.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.AreEqual(result.Id, notContestedDispute.Id);
}
public void Test_GetDocumentsForDispute()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.SUBMITTED);
if (dispute == null)
{
Test_ContestDispute();
Initialize();
dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.SUBMITTED);
if (dispute == null)
{
Assert.Fail("Cannot test getting dispute's documents because there's no available disputes with SUBMITTED status in the disputes list.");
}
}
ListPaginated <DisputeDocumentDTO> result = null;
try
{
result = Api.Disputes.GetDocumentsForDispute(dispute.Id, new Pagination(1, 1), null);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
}
public async Task Test_GetRepudiation()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.InitialTransactionId != null && x.DisputeType.HasValue && x.DisputeType.Value == DisputeType.NOT_CONTESTABLE);
RepudiationDTO result = null;
if (dispute == null)
{
Assert.Fail("Cannot test getting repudiation because there's no not contestable disputes with transaction ID in the disputes list.");
}
try
{
var temp = await Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null);
string repudiationId = temp[0].Id;
result = await Api.Disputes.GetRepudiation(repudiationId);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
}
/// <summary>
/// Reads messages and if they contain data it gets set to appropriate members
/// </summary>
private void parseNewMessage(WCFMessage msg)
{
if (connected)
{
if (msg == null)
{
return;
}
myDTO = msg.Data;
switch (msg.Type)
{
case Messages.DTOType.lobby:
parseLobbyDTO(msg.Data);
break;
case Messages.DTOType.message:
sendFeedback("parseNewMessage", msg.Data.Message);
break;
case Messages.DTOType.match:
parseMatchDTO(msg.Data);
break;
default:
break;
}
}
}
public void Test_Idempotency_DisputesRepudiationCreateSettlement()
{
string key = DateTime.Now.Ticks.ToString();
Sort sort = new Sort();
sort.AddField("CreationDate", SortDirection.desc);
var clientDisputes = Api.Disputes.GetAll(new Pagination(1, 100), null, sort);
if (clientDisputes == null || clientDisputes.Count == 0)
{
Assert.Fail("INITIALIZATION FAILURE - cannot test disputes");
}
DisputeDTO dispute = clientDisputes.FirstOrDefault(x =>
x.Status == DisputeStatus.CLOSED && x.DisputeType == DisputeType.NOT_CONTESTABLE);
if (dispute == null)
{
Assert.Fail(
"Cannot test creating settlement transfer because there's no closed disputes in the disputes list.");
}
string repudiationId = Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null)[0].Id;
var repudiation = Api.Disputes.GetRepudiation(repudiationId);
SettlementTransferPostDTO post = new SettlementTransferPostDTO(repudiation.AuthorId,
new Money {
Currency = CurrencyIso.EUR, Amount = 1
}, new Money {
Currency = CurrencyIso.EUR, Amount = 0
});
Api.Disputes.CreateSettlementTransfer(key, post, repudiationId);
var result = Api.Idempotency.Get(key);
Assert.IsInstanceOf <SettlementDTO>(result.Resource);
}
public void Test_SubmitDisputeDocument()
{
DisputeDTO dispute = null;
DisputeDocumentDTO disputeDocument = null;
FilterDisputeDocuments filter = new FilterDisputeDocuments();
filter.Status = DisputeDocumentStatus.CREATED;
// search for dispute having any documents created
foreach (DisputeDTO d in _clientDisputes.Where(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION))
{
DisputeDocumentDTO dd = Api.Disputes.GetDocumentsForDispute(d.Id, new Pagination(1, 1), filter).FirstOrDefault();
if (dd != null)
{ // found
dispute = d;
disputeDocument = dd;
break;
}
}
if (dispute == null)
{
dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
if (dispute == null)
{
Assert.Fail("Cannot test submitting dispute's documents because there's no dispute with expected status in the disputes list.");
}
DisputeDocumentPostDTO documentPost = new DisputeDocumentPostDTO(DisputeDocumentType.DELIVERY_PROOF);
disputeDocument = Api.Disputes.CreateDisputeDocument(documentPost, dispute.Id);
}
DisputeDocumentDTO result = null;
try
{
if (disputeDocument == null)
{
Assert.Fail("Cannot test submitting dispute's documents because there's no dispute document that can be updated.");
}
DisputeDocumentPutDTO disputeDocumentPut = new DisputeDocumentPutDTO
{
Status = DisputeDocumentStatus.VALIDATION_ASKED
};
result = Api.Disputes.SubmitDisputeDocument(disputeDocumentPut, dispute.Id, disputeDocument.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.IsTrue(disputeDocument.Type == result.Type);
Assert.IsTrue(result.Status == DisputeDocumentStatus.VALIDATION_ASKED);
}
public void Test_CreateSettlementTransfer()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.CLOSED && x.DisputeType == DisputeType.NOT_CONTESTABLE);
RepudiationDTO repudiation = null;
SettlementDTO result = null;
if (dispute == null)
{
Assert.Fail("Cannot test creating settlement transfer because there's no closed disputes in the disputes list.");
}
try
{
string repudiationId = Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null)[0].Id;
repudiation = Api.Disputes.GetRepudiation(repudiationId);
SettlementTransferPostDTO post = new SettlementTransferPostDTO(repudiation.AuthorId, new Money {
Currency = CurrencyIso.EUR, Amount = 1
}, new Money {
Currency = CurrencyIso.EUR, Amount = 0
});
result = Api.Disputes.CreateSettlementTransfer(post, repudiationId);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
}
public async Task Test_GetDisputesForWallet()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.InitialTransactionId != null);
if (dispute == null)
{
Assert.Fail("Cannot test getting disputes for wallet because there's no disputes with transaction ID in the disputes list.");
}
ListPaginated <DisputeDTO> result = null;
try
{
var temp = await Api.PayIns.Get(dispute.InitialTransactionId);
string walletId = temp.CreditedWalletId;
result = await Api.Disputes.GetDisputesForWallet(walletId, new Pagination(1, 10), null);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
}
public void Test_GetDocument()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
if (dispute == null)
{
Assert.Fail("Cannot test getting dispute's document because there's no dispute with expected status in the disputes list.");
}
DisputeDocumentDTO document = null;
DisputeDocumentDTO result = null;
try
{
DisputeDocumentPostDTO documentPost = new DisputeDocumentPostDTO(DisputeDocumentType.OTHER);
document = Api.Disputes.CreateDisputeDocument(documentPost, dispute.Id);
result = Api.Disputes.GetDocument(document.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.AreEqual(result.CreationDate, document.CreationDate);
Assert.AreEqual(result.Id, document.Id);
Assert.AreEqual(result.RefusedReasonMessage, document.RefusedReasonMessage);
Assert.AreEqual(result.RefusedReasonType, document.RefusedReasonType);
Assert.AreEqual(result.Status, document.Status);
Assert.AreEqual(result.Tag, document.Tag);
Assert.AreEqual(result.Type, document.Type);
Assert.AreEqual(result.DisputeId, document.DisputeId);
}
public void Test_CreateDisputePage()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
if (dispute == null)
{
Assert.Fail("Cannot test creating dispute document page because there's no dispute with expected status in the disputes list.");
}
DisputeDocumentDTO result = null;
try
{
DisputeDocumentPostDTO documentPost = new DisputeDocumentPostDTO(DisputeDocumentType.DELIVERY_PROOF);
result = Api.Disputes.CreateDisputeDocument(documentPost, dispute.Id);
Api.Disputes.CreateDisputePage(dispute.Id, result.Id, "TestKycPageFile.png");
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.AreEqual(result.Type, DisputeDocumentType.DELIVERY_PROOF);
}
public DisputeDTO getMatchDTO(Match m)
{
DisputeDTO DTO = new DisputeDTO()
{
Match = m, Message = Messages.GameMessages.UpdateMatch
};
return(DTO);
}
public DisputeDTO getLobbyDTO()
{
DisputeDTO DTO = new DisputeDTO()
{
Matches = this.Matches, Players = this.players
};
return(DTO);
}
public async Task Test_GetSettlementTransfer()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.CLOSED && x.DisputeType.HasValue && x.DisputeType.Value == DisputeType.NOT_CONTESTABLE);
RepudiationDTO repudiation = null;
SettlementDTO transfer = null;
if (dispute == null)
{
Assert.Fail("Cannot test getting settlement transfer because there's no closed and not contestable disputes in the disputes list.");
}
try
{
var temp = await Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 1), null);
string repudiationId = temp[0].Id;
repudiation = await Api.Disputes.GetRepudiation(repudiationId);
SettlementTransferPostDTO post = new SettlementTransferPostDTO(repudiation.AuthorId, new Money {
Currency = CurrencyIso.EUR, Amount = 1
}, new Money {
Currency = CurrencyIso.EUR, Amount = 0
});
transfer = await Api.Disputes.CreateSettlementTransfer(post, repudiationId);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(transfer);
SettlementDTO result = null;
try
{
result = await Api.Disputes.GetSettlementTransfer(transfer.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.IsInstanceOf <SettlementDTO>(result);
Assert.IsNotNull(result.RepudiationId);
Assert.AreEqual(result.RepudiationId, repudiation.Id);
}
public void Test_GetDispute()
{
DisputeDTO dispute = null;
try
{
dispute = Api.Disputes.Get(_clientDisputes[0].Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(dispute);
Assert.AreEqual(dispute.Id, _clientDisputes[0].Id);
}
public void Test_SaveTag()
{
DisputeDTO result = null;
string newTag = "New tag: " + DateTime.UtcNow.Ticks.ToString();
try
{
result = Api.Disputes.UpdateTag(newTag, _clientDisputes[0].Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.AreEqual(result.Tag, newTag);
}
/// <summary>
/// This method is used to get messages from the Model layer (GameDispute), and pass them on to the players.
///
/// </summary>
/// <param name="msg"></param>
/// <param name="player"></param>
/// <param name="data"></param>
void IGameObserver.update(DataPlayer player, Messages.GameMessages msg, List <object> data)
{
DisputeDTO dto = null;
switch (msg)
{
case Messages.GameMessages.GetSOM:
dto = new DisputeDTO()
{
SomRequest = (SoMRequest)data[0], Message = Messages.GameMessages.GetSOM
};
goto case Messages.GameMessages.none;
case Messages.GameMessages.ArgumentDone:
break;
case Messages.GameMessages.GameOver:
dto = new DisputeDTO()
{
Message = Messages.GameMessages.GameOver
};
goto case Messages.GameMessages.none;
case Messages.GameMessages.NotPlayerTurn:
dto = new DisputeDTO()
{
Message = Messages.GameMessages.NotPlayerTurn
};
goto case Messages.GameMessages.none;
case Messages.GameMessages.none:
this.MyMessages[player.PlayerName].Add(new WCFMessage()
{
Player = player,
Type = Messages.DTOType.match,
Data = dto
});
break;
default:
break;
}
}
public void Test_CloseDispute()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.PENDING_CLIENT_ACTION || x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
if (dispute == null)
{
Assert.Fail("Cannot test closing dispute because there's no available disputes with expected status in the disputes list.");
}
DisputeDTO result = null;
try
{
result = Api.Disputes.CloseDispute(dispute.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
}
/// <summary>
/// Decision Maker when game is playing.Gets messages from server and decides what to do with them
/// </summary>
/// <param name="disputeDTO"></param>
private void parseMatchDTO(DisputeDTO disputeDTO)
{
Messages.GameMessages dtoMessage = disputeDTO.Message;
serverMessage = dtoMessage;
switch (dtoMessage)
{
case Messages.GameMessages.StartingMatch:
this.inMatch = disputeDTO.Match;
viewMessage = Messages.LobbyViewMessage.StartGame;
break;
case Messages.GameMessages.ArgumentDone:
this.inMatch = disputeDTO.Match;
break;
case Messages.GameMessages.GetSOM:
serverMessage = dtoMessage; //this was already done above but just emphasize
myDTO = disputeDTO;
break;
case Messages.GameMessages.NotPlayerTurn:
sendFeedback("parseMatchDTO", dtoMessage);
break;
case Messages.GameMessages.UpdateMatch:
this.inMatch = disputeDTO.Match;
break;
case Messages.GameMessages.stillAlive:
this.inMatch = disputeDTO.Match;
break;
case Messages.GameMessages.GameOver:
serverMessage = dtoMessage; //this was already done above but just emphasize
break;
}
}
public void Test_GetTransactions()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.DisputeType.HasValue && x.DisputeType.Value == DisputeType.NOT_CONTESTABLE);
if (dispute == null)
{
Assert.Fail("Cannot test getting transactions for dispute there's no not contestable disputes in the disputes list.");
}
ListPaginated <TransactionDTO> result = null;
try
{
result = Api.Disputes.GetTransactions(dispute.Id, new Pagination(1, 10), null);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
}
public void Test_ResubmitDispute()
{
DisputeDTO dispute = _clientDisputes.FirstOrDefault(x => x.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION);
DisputeDTO result = null;
if (dispute == null)
{
Assert.Fail("Cannot test resubmitting dispute because there's no re-opened disputes in the disputes list.");
}
try
{
result = Api.Disputes.ResubmitDispute(dispute.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
Assert.IsNotNull(result);
Assert.IsTrue(result.Status == DisputeStatus.SUBMITTED);
}
/// <summary>
/// Gets messages from server when in lobby. It basically just sets Matches data.
/// </summary>
/// <param name="dto"></param>
void parseLobbyDTO(DisputeDTO dto)
{
this.matches = dto.Matches;
this.Players = dto.Players;
this.player = this.Players.Find(n => n.PlayerName.Equals(player.PlayerName));
}
