//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyTransaction(TransactionIdStore transactionIdStore, TransactionMetadataCache positionCache, byte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted, LogicalTransactionStore store) throws java.io.IOException
private void VerifyTransaction(TransactionIdStore transactionIdStore, TransactionMetadataCache positionCache, sbyte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted, LogicalTransactionStore store)
{
TransactionMetadata expectedMetadata;
using (TransactionCursor cursor = store.GetTransactions(TransactionIdStore_Fields.BASE_TX_ID + 1))
{
bool hasNext = cursor.next();
assertTrue(hasNext);
CommittedTransactionRepresentation tx = cursor.get();
TransactionRepresentation transaction = tx.TransactionRepresentation;
assertArrayEquals(additionalHeader, transaction.AdditionalHeader());
assertEquals(masterId, transaction.MasterId);
assertEquals(authorId, transaction.AuthorId);
assertEquals(timeStarted, transaction.TimeStarted);
assertEquals(timeCommitted, transaction.TimeCommitted);
assertEquals(latestCommittedTxWhenStarted, transaction.LatestCommittedTxWhenStarted);
expectedMetadata = new TransactionMetadata(masterId, authorId, tx.StartEntry.StartPosition, tx.StartEntry.checksum(), timeCommitted);
}
positionCache.Clear();
TransactionMetadata actualMetadata = store.GetMetadataFor(transactionIdStore.LastCommittedTransactionId);
assertEquals(expectedMetadata, actualMetadata);
}
private ImmutableTransaction BuildTestTransaction(string uri = null, string guid = null, int?statusCode = null, int?subStatusCode = null, IEnumerable <ErrorData> transactionExceptionDatas = null)
{
var transactionMetadata = new TransactionMetadata();
if (uri != null)
{
transactionMetadata.SetUri(uri);
}
if (statusCode != null)
{
transactionMetadata.SetHttpResponseStatusCode(statusCode.Value, subStatusCode, _errorService);
}
if (transactionExceptionDatas != null)
{
transactionExceptionDatas.ForEach(data => transactionMetadata.TransactionErrorState.AddExceptionData(data));
}
var name = TransactionName.ForWebTransaction("foo", "bar");
var segments = Enumerable.Empty <Segment>();
var metadata = transactionMetadata.ConvertToImmutableMetadata();
guid = guid ?? Guid.NewGuid().ToString();
var attribDefSvc = new AttributeDefinitionService((f) => new AttributeDefinitions(f));
return(new ImmutableTransaction(name, segments, metadata, DateTime.UtcNow, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), guid, false, false, false, 0.5f, false, string.Empty, null, attribDefSvc.AttributeDefs));
}
private IInternalTransaction BuildTestTransaction(bool isWebTransaction = true, string uri = null, string referrerUri = null, string guid = null, int?statusCode = null, int?subStatusCode = null, string referrerCrossProcessId = null, string transactionCategory = "defaultTxCategory", string transactionName = "defaultTxName", ErrorData exceptionData = null, ErrorData customErrorData = null, bool isSynthetics = true, bool isCAT = true, bool includeUserAttributes = false, float priority = 0.5f, bool sampled = false, string traceId = "traceId")
{
var name = isWebTransaction
? TransactionName.ForWebTransaction(transactionCategory, transactionName)
: TransactionName.ForOtherTransaction(transactionCategory, transactionName);
var segments = Enumerable.Empty <Segment>();
var placeholderMetadataBuilder = new TransactionMetadata();
var placeholderMetadata = placeholderMetadataBuilder.ConvertToImmutableMetadata();
var immutableTransaction = new ImmutableTransaction(name, segments, placeholderMetadata, DateTime.UtcNow, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), guid, false, false, false, priority, sampled, traceId, null, _attribDefs);
var internalTransaction = new Transaction(Mock.Create <IConfiguration>(), immutableTransaction.TransactionName, _timerFactory.StartNewTimer(), DateTime.UtcNow, Mock.Create <ICallStackManager>(), Mock.Create <IDatabaseService>(), priority, Mock.Create <IDatabaseStatementParser>(), Mock.Create <IDistributedTracePayloadHandler>(), Mock.Create <IErrorService>(), _attribDefs);
var adaptiveSampler = Mock.Create <IAdaptiveSampler>();
Mock.Arrange(() => adaptiveSampler.ComputeSampled(ref priority)).Returns(sampled);
internalTransaction.SetSampled(adaptiveSampler);
var transactionMetadata = internalTransaction.TransactionMetadata;
PopulateTransactionMetadataBuilder(transactionMetadata, uri, statusCode, subStatusCode, referrerCrossProcessId, exceptionData, customErrorData, isSynthetics, isCAT, referrerUri, includeUserAttributes);
return(internalTransaction);
}
public async Task<ByteString> PostTransaction(ByteString rawMutation, IReadOnlyList<SignatureEvidence> authentication)
{
Mutation mutation;
try
{
// Verify that the mutation can be deserialized
mutation = MessageSerializer.DeserializeMutation(rawMutation);
}
catch (InvalidProtocolBufferException)
{
throw new TransactionInvalidException("InvalidMutation");
}
if (!mutation.Namespace.Equals(this.ledgerId))
throw new TransactionInvalidException("InvalidNamespace");
if (mutation.Records.Count == 0)
throw new TransactionInvalidException("InvalidMutation");
if (mutation.Records.Any(record => record.Key.Value.Count > MaxKeySize))
throw new TransactionInvalidException("InvalidMutation");
ValidateAuthentication(authentication, MessageSerializer.ComputeHash(rawMutation.ToByteArray()));
ParsedMutation parsedMutation = ParsedMutation.Parse(mutation);
// All assets must have an overall zero balance
IReadOnlyDictionary<AccountKey, AccountStatus> accounts =
await this.store.GetAccounts(parsedMutation.AccountMutations.Select(entry => entry.AccountKey));
var groups = parsedMutation.AccountMutations
.GroupBy(account => account.AccountKey.Asset.FullPath)
.Select(group => group.Sum(entry => entry.Balance - accounts[entry.AccountKey].Balance));
if (groups.Any(group => group != 0))
throw new TransactionInvalidException("UnbalancedTransaction");
DateTime date = DateTime.UtcNow;
await this.validator.Validate(parsedMutation, authentication, accounts);
TransactionMetadata metadata = new TransactionMetadata(authentication);
byte[] rawMetadata = SerializeMetadata(metadata);
Transaction transaction = new Transaction(rawMutation, date, new ByteString(rawMetadata));
byte[] serializedTransaction = MessageSerializer.SerializeTransaction(transaction);
try
{
await this.store.AddTransactions(new[] { new ByteString(serializedTransaction) });
}
catch (ConcurrentMutationException)
{
throw new TransactionInvalidException("OptimisticConcurrency");
}
return new ByteString(MessageSerializer.ComputeHash(serializedTransaction));
}
public async Task <DomainValidationResult <ITransaction> > MarkAccountTransactionAsCanceledAsync(
IAccount account,
TransactionMetadata metadata,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <ITransaction>();
if (!account.TransactionExists(metadata))
{
result.AddFailedPreconditionError("Transaction does not exists.");
}
if (result.IsValid)
{
var transaction = account.FindTransaction(metadata);
transaction.MarkAsCanceled();
await _accountRepository.CommitAsync(true, cancellationToken);
return(transaction.Cast <Transaction>());
}
return(result);
}
public ActionResult TransactionCompleate(TransactionMetadata transactionMetadata, string command)
{
var transaction = GetTransactionSession();
transaction.InvoiceNumber = transactionMetadata.InvoiceNumber;
transaction.TransactionDate = transactionMetadata.TransactionDate;
SetTransactionSession(transaction);
switch (command)
{
case "Add SKU":
return(RedirectToAction("SkuList"));
case "Save":
if (_transaction.TransctionCompleate(transaction))
{
ResetSession();
return(RedirectToAction("Home", "Dashboard"));
}
return(View("Transaction", transactionMetadata));
default:
ResetSession();
return(RedirectToAction("Home", "Dashboard"));
}
}
public async Task WithdrawAsync_WithWrongBundle_ShouldBeOfTypeValidationResultWithErrors()
{
// Arrange
var account = new Account(new UserId());
var metadata = new TransactionMetadata
{
{ "UserId", account.Id.ToString() },
{ "Email", "*****@*****.**" }
};
var service = new AccountService(TestMock.AccountRepository.Object, TestValidator);
// Act
var result = await service.CreateTransactionAsync(
account,
Money.Twenty.Amount,
CurrencyType.Money,
TransactionType.Withdraw,
metadata);
// Assert
result.Should().BeOfType <DomainValidationResult <ITransaction> >();
result.Errors.Should().NotBeEmpty();
}
public async Task WithdrawAsync_WithCurrencyMoney_ShouldBeOfTypeValidationResult()
{
// Arrange
var account = new Account(new UserId());
var moneyAccount = new MoneyAccountDecorator(account);
var transaction = moneyAccount.Deposit(Money.OneHundred);
transaction.MarkAsSucceeded();
TestMock.AccountRepository.Setup(accountRepository => accountRepository.CommitAsync(true, It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var metadata = new TransactionMetadata
{
{ "UserId", account.Id.ToString() },
{ "Email", "*****@*****.**" }
};
var service = new AccountService(TestMock.AccountRepository.Object, TestValidator);
// Act
var result = await service.CreateTransactionAsync(
moneyAccount,
Money.OneHundred.Amount,
CurrencyType.Money,
TransactionType.Withdraw,
metadata);
// Assert
result.Should().BeOfType <DomainValidationResult <ITransaction> >();
TestMock.AccountRepository.Verify(accountRepository => accountRepository.CommitAsync(true, It.IsAny <CancellationToken>()), Times.Once());
}
public bool TransctionCompleate(TransactionMetadata transactionMetadata)
{
var transaction = new Entitys.Transaction
{
InvoiceNumber = transactionMetadata.InvoiceNumber,
TransactionDate = transactionMetadata.TransactionDate,
IsSales = transactionMetadata.IsSales
};
var totalAmount = transactionMetadata.Products.Sum(x => x.Amount);
if (transactionMetadata.IsSales)
{
transaction.SalesAmount = totalAmount;
}
else
{
transaction.PurchaseAmount = totalAmount;
}
foreach (var product in transactionMetadata.Products)
{
var skuId = Convert.ToInt64(product.SkuId);
var transctionHistory = new TransactionHistory
{
Amount = product.Amount,
BrandId = Convert.ToInt64(product.BrandId),
CompnayId = Convert.ToInt64(product.CompanyId),
ProductId = Convert.ToInt64(product.ProductId),
Quantity = product.Quantity,
Rate = product.Rate,
SkuId = skuId,
Transaction = transaction
};
_basicUnit.TransactionHistorys.Add(transctionHistory);
var stockInfo = _basicUnit.Stocks.GetStockBySkuId(skuId);
if (transactionMetadata.IsSales)
{
stockInfo.Quantity -= product.Quantity;
}
else
{
stockInfo.Quantity += product.Quantity;
}
stockInfo.Rate = product.Rate;
}
_basicUnit.Transactions.Add(transaction);
try
{
_basicUnit.Save();
return(true);
}
catch (Exception)
{
return(false);
}
}
public void Build_HasEmptyPathHashIfNeverSet()
{
var transactionMetadata = new TransactionMetadata();
var immutableMetadata = transactionMetadata.ConvertToImmutableMetadata();
NrAssert.Multiple(
() => Assert.AreEqual(null, immutableMetadata.CrossApplicationPathHash),
() => Assert.AreEqual(0, immutableMetadata.CrossApplicationAlternatePathHashes.Count())
);
}
internal Transaction(AccountId accId, TransactionId id, TransactionLabel label, ITransactionAmount amount, TransactionMetadata meta, TransactionDescription descr, DateTime createdOn, DateTime updatedOn)
{
AccountId = accId;
Id = id;
Label = label;
Amount = amount;
Metadata = meta;
Description = descr;
CreatedOn = createdOn;
UpdatedOn = updatedOn;
}
public virtual TransactionMetadata CacheTransactionMetadata(long txId, LogPosition position, int masterId, int authorId, long checksum, long timeWritten)
{
if (position.ByteOffset == -1)
{
throw new Exception("StartEntry.position is " + position);
}
TransactionMetadata result = new TransactionMetadata(masterId, authorId, position, checksum, timeWritten);
_txStartPositionCache.put(txId, result);
return(result);
}
public void Build_HasZeroAlternatePathHashesIfSetOnce()
{
var metadata = new TransactionMetadata();
metadata.SetCrossApplicationPathHash("pathHash1");
var immutableMetadata = metadata.ConvertToImmutableMetadata();
NrAssert.Multiple(
() => Assert.AreEqual("pathHash1", immutableMetadata.CrossApplicationPathHash),
() => Assert.AreEqual(0, immutableMetadata.CrossApplicationAlternatePathHashes.Count())
);
}
public void Getters_CATContentLength()
{
var metadata = new TransactionMetadata();
Assert.AreEqual(-1, metadata.GetCrossApplicationReferrerContentLength());
metadata.SetCrossApplicationReferrerContentLength(44444);
Assert.AreEqual(44444, metadata.GetCrossApplicationReferrerContentLength());
metadata.SetCrossApplicationReferrerContentLength(5432);
Assert.AreEqual(5432, metadata.GetCrossApplicationReferrerContentLength());
}
public void Getters_QueueTime()
{
var metadata = new TransactionMetadata();
Assert.IsNull(metadata.QueueTime);
metadata.SetQueueTime(TimeSpan.FromSeconds(20));
Assert.AreEqual(20, metadata.QueueTime?.Seconds);
metadata.SetQueueTime(TimeSpan.FromSeconds(55));
Assert.AreEqual(55, metadata.QueueTime?.Seconds);
}
private byte[] SerializeMetadata(TransactionMetadata metadata)
{
Messages.TransactionMetadata transactionMetadataBuilder = new Messages.TransactionMetadata();
transactionMetadataBuilder.Signatures.Add(metadata.Signatures.Select(
signature => new Messages.TransactionMetadata.Types.SignatureEvidence()
{
PublicKey = Google.Protobuf.ByteString.Unsafe.FromBytes(signature.PublicKey.ToByteArray()),
Signature = Google.Protobuf.ByteString.Unsafe.FromBytes(signature.Signature.ToByteArray())
}));
return(transactionMetadataBuilder.ToByteArray());
}
private ImmutableTransaction BuildTestImmutableTransaction(bool isWebTransaction = true, string guid = null, float priority = 0.5f, bool sampled = false, string traceId = "traceId", bool isDTParticipant = false)
{
var name = TransactionName.ForWebTransaction("category", "name");
var segments = Enumerable.Empty <Segment>();
var placeholderMetadataBuilder = new TransactionMetadata();
var placeholderMetadata = placeholderMetadataBuilder.ConvertToImmutableMetadata();
var immutableTransaction = new ImmutableTransaction(name, segments, placeholderMetadata, DateTime.UtcNow, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), guid, false, false, false, priority, sampled, traceId, BuildMockTracingState(isDTParticipant), _attribDefs);
return(immutableTransaction);
}
public static IInternalTransaction CreateDefaultTransaction(bool isWebTransaction = true, string uri = null,
string guid = null, int?statusCode = null, int?subStatusCode = null, string referrerCrossProcessId = null,
string transactionCategory = "defaultTxCategory", string transactionName = "defaultTxName", bool addSegment = true,
IEnumerable <Segment> segments = null, bool sampled = false, IConfigurationService configurationService = null, Exception exception = null)
{
var name = isWebTransaction
? TransactionName.ForWebTransaction(transactionCategory, transactionName)
: TransactionName.ForOtherTransaction(transactionCategory, transactionName);
segments = segments ?? Enumerable.Empty <Segment>();
var placeholderMetadataBuilder = new TransactionMetadata();
var placeholderMetadata = placeholderMetadataBuilder.ConvertToImmutableMetadata();
var immutableTransaction = new ImmutableTransaction(name, segments, placeholderMetadata, DateTime.Now, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), guid, false, false, false, 0.5f, false, string.Empty, null, _attribDefSvc.AttributeDefs);
var priority = 0.5f;
var configuration = configurationService?.Configuration ?? GetDefaultConfiguration();
var errorService = configurationService != null ? new ErrorService(configurationService) : new ErrorService(Mock.Create <IConfigurationService>());
var internalTransaction = new Transaction(configuration, immutableTransaction.TransactionName, Mock.Create <ITimer>(), DateTime.UtcNow, Mock.Create <ICallStackManager>(),
_databaseService, priority, Mock.Create <IDatabaseStatementParser>(), Mock.Create <IDistributedTracePayloadHandler>(),
errorService, _attribDefSvc.AttributeDefs);
if (exception != null)
{
internalTransaction.NoticeError(exception);
}
if (segments.Any())
{
foreach (var segment in segments)
{
internalTransaction.Add(segment);
}
}
else if (addSegment)
{
internalTransaction.Add(SimpleSegmentDataTests.createSimpleSegmentBuilder(TimeSpan.Zero, TimeSpan.Zero, 0, null, new MethodCallData("typeName", "methodName", 1), Enumerable.Empty <KeyValuePair <string, object> >(), "MyMockedRootNode", false));
}
var adaptiveSampler = Mock.Create <IAdaptiveSampler>();
Mock.Arrange(() => adaptiveSampler.ComputeSampled(ref priority)).Returns(sampled);
internalTransaction.SetSampled(adaptiveSampler);
var transactionMetadata = internalTransaction.TransactionMetadata;
PopulateTransactionMetadataBuilder(transactionMetadata, errorService, uri, statusCode, subStatusCode, referrerCrossProcessId);
return(internalTransaction);
}
public KeyValuePair <bool, TransactionMetadata> AddSkuToInvoice(TransactionMetadata transactionMetadata, SkuForTransactionMetadata skuForTransactionMetadata)
{
if (transactionMetadata.Products == null)
{
transactionMetadata.Products = new List <StockMetaData>();
}
var skuFortansaction = transactionMetadata.Products.FirstOrDefault(x => x.SkuId == skuForTransactionMetadata.SkuId);
if (skuFortansaction != null)
{
if (transactionMetadata.IsSales)
{
if (skuForTransactionMetadata.SkuId != null)
{
var stackInfo = _basicUnit.Stocks.GetStockBySkuId((Int64)skuForTransactionMetadata.SkuId);
if ((skuFortansaction.Quantity + skuForTransactionMetadata.TransactionQuantity) > stackInfo.Quantity)
{
return(new KeyValuePair <bool, TransactionMetadata>(false, transactionMetadata));
}
}
}
skuFortansaction.Quantity += skuForTransactionMetadata.TransactionQuantity;
skuForTransactionMetadata.Rate = skuForTransactionMetadata.TransactionRate;
skuForTransactionMetadata.Amount = skuForTransactionMetadata.TransactionAmount;
return(new KeyValuePair <bool, TransactionMetadata>(true, transactionMetadata));
}
if (skuForTransactionMetadata.SkuId != null)
{
var skuInfo = _basicUnit.Skus.GetSkuById((Int64)skuForTransactionMetadata.SkuId);
transactionMetadata.Products.Add(new StockMetaData
{
Amount = skuForTransactionMetadata.TransactionAmount,
BrandId = skuInfo.BrandId,
SkuName = skuInfo.SkuName,
BrandName = skuInfo.BrandName,
CompanyId = skuInfo.CompanyId,
CompanyName = skuInfo.CompanyName,
ProductId = skuInfo.ProductId,
ProductName = skuInfo.ProductName,
Quantity = skuForTransactionMetadata.TransactionQuantity,
Rate = skuForTransactionMetadata.TransactionRate,
SkuId = skuForTransactionMetadata.SkuId
});
return(new KeyValuePair <bool, TransactionMetadata>(true, transactionMetadata));
}
return(new KeyValuePair <bool, TransactionMetadata>(false, transactionMetadata));
}
public override bool Equals(object o)
{
if (this == o)
{
return(true);
}
if (o == null || this.GetType() != o.GetType())
{
return(false);
}
TransactionMetadata that = ( TransactionMetadata )o;
return(MasterIdConflict == that.MasterIdConflict && AuthorIdConflict == that.AuthorIdConflict && ChecksumConflict == that.ChecksumConflict && TimeWrittenConflict == that.TimeWrittenConflict && Objects.Equals(StartPositionConflict, that.StartPositionConflict));
}
private ImmutableTransaction BuildTestTransaction(bool ignoreAutoBrowserMonitoring = false, bool ignoreAllBrowserMonitoring = false)
{
var name = TransactionName.ForWebTransaction("foo", "bar");
var segments = Enumerable.Empty <Segment>();
var metadata = new TransactionMetadata().ConvertToImmutableMetadata();
var guid = Guid.NewGuid().ToString();
_internalTransaction = Mock.Create <IInternalTransaction>();
Mock.Arrange(() => _internalTransaction.IgnoreAllBrowserMonitoring).Returns(ignoreAllBrowserMonitoring);
Mock.Arrange(() => _internalTransaction.IgnoreAutoBrowserMonitoring).Returns(ignoreAutoBrowserMonitoring);
var attribDefSvc = new AttributeDefinitionService((f) => new AttributeDefinitions(f));
return(new ImmutableTransaction(name, segments, metadata, DateTime.UtcNow, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), guid, ignoreAutoBrowserMonitoring, ignoreAllBrowserMonitoring, false, 0.5f, false, string.Empty, null, attribDefSvc.AttributeDefs));
}
private ImmutableTransaction BuildTestTransaction(IEnumerable <Segment> segments = null, DateTime?startTime = null)
{
var transactionMetadata = new TransactionMetadata();
var name = TransactionName.ForWebTransaction("foo", "bar");
segments = segments ?? Enumerable.Empty <Segment>();
var metadata = transactionMetadata.ConvertToImmutableMetadata();
startTime = startTime ?? DateTime.Now;
var duration = TimeSpan.FromSeconds(1);
var guid = Guid.NewGuid().ToString();
return(new ImmutableTransaction(name, segments, metadata, startTime.Value, duration, duration, guid, false, false, false, 1.23f, false, string.Empty, null, _attribDefs));
}
public void Build_OnlyRetainsACertainNumberOfAlternatePathHashes()
{
var maxPathHashes = PathHashMaker.AlternatePathHashMaxSize;
var transactionMetadata = new TransactionMetadata();
Enumerable.Range(0, maxPathHashes + 2).ForEach(number => transactionMetadata.SetCrossApplicationPathHash($"pathHash{number}"));
var immutableMetadata = transactionMetadata.ConvertToImmutableMetadata();
NrAssert.Multiple(
() => Assert.AreEqual($"pathHash{PathHashMaker.AlternatePathHashMaxSize + 1}", immutableMetadata.CrossApplicationPathHash),
() => Assert.AreEqual(PathHashMaker.AlternatePathHashMaxSize, immutableMetadata.CrossApplicationAlternatePathHashes.Count()),
() => Assert.IsFalse(immutableMetadata.CrossApplicationAlternatePathHashes.Contains($"pathHash{PathHashMaker.AlternatePathHashMaxSize + 1}"))
);
}
public void Build_PutsAllPathHashesIntoAlternatePathHashes_ExceptLatest()
{
var metadata = new TransactionMetadata();
metadata.SetCrossApplicationPathHash("pathHash1");
metadata.SetCrossApplicationPathHash("pathHash2");
metadata.SetCrossApplicationPathHash("pathHash3");
var immutableMetadata = metadata.ConvertToImmutableMetadata();
NrAssert.Multiple(
() => Assert.AreEqual("pathHash3", immutableMetadata.CrossApplicationPathHash),
() => Assert.AreEqual(2, immutableMetadata.CrossApplicationAlternatePathHashes.Count()),
() => Assert.IsTrue(immutableMetadata.CrossApplicationAlternatePathHashes.Contains("pathHash1")),
() => Assert.IsTrue(immutableMetadata.CrossApplicationAlternatePathHashes.Contains("pathHash2"))
);
}
public static ImmutableTransaction CreateTestTransactionWithSegments(IEnumerable <Segment> segments)
{
var uri = "sqlTrace/Uri";
var transactionMetadata = new TransactionMetadata();
transactionMetadata.SetUri(uri);
var name = TransactionName.ForWebTransaction("TxsWithSegments", "TxWithSegmentX");
var metadata = transactionMetadata.ConvertToImmutableMetadata();
var guid = Guid.NewGuid().ToString();
var transaction = new ImmutableTransaction(name, segments, metadata, DateTime.UtcNow, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), guid, false, false, false, 0.5f, false, string.Empty, null, _attribDefSvc.AttributeDefs);
return(transaction);
}
public static MemoryPoolEntry CreateMemoryPoolEntry(TransactionMetadata walletTransaction, TransactionBroadcastEntry broadcastEntry)
{
var entry = new MemoryPoolEntry
{
Transaction = walletTransaction,
TransactionTime = DateTime.UtcNow.ToUnixTime()
};
if (broadcastEntry != null)
{
entry.BroadcastState = broadcastEntry.State.ToBroadcastState();
entry.MemoryPoolError = broadcastEntry.MempoolError.GetMemoryPoolError();
entry.ConsensusError = broadcastEntry.MempoolError.GetMemoryPoolError();
}
return(entry);
}
public void TransactionExists_WithInvalidTransactionMetadata_ShouldThrowInvalidOperationException(
TransactionMetadata transactionMetadata,
TransactionMetadata transactionMetadataQuery
)
{
// Arrange
var account = new Account(new UserId());
var moneyAccount = new MoneyAccountDecorator(account);
moneyAccount.Deposit(Money.Fifty).MarkAsSucceeded();
moneyAccount.Charge(Money.Ten, transactionMetadata);
// Act
var transactionExists = account.TransactionExists(transactionMetadataQuery);
// Assert
transactionExists.Should().BeFalse();
}
public void FindTransaction_WithValidTransactionMetadata_ShouldBeEquals(
TransactionMetadata transactionMetadata,
TransactionMetadata transactionMetadataQuery
)
{
// Arrange
var account = new Account(new UserId());
var moneyAccount = new MoneyAccountDecorator(account);
moneyAccount.Deposit(Money.Fifty).MarkAsSucceeded();
var expectedTransaction = moneyAccount.Charge(Money.Ten, transactionMetadata);
// Act
var actualTransaction = account.FindTransaction(transactionMetadataQuery);
// Assert
actualTransaction.Should().Be(expectedTransaction);
}
public void FindTransaction_WithInvalidTransactionMetadata_ShouldThrowInvalidOperationException(
TransactionMetadata transactionMetadata,
TransactionMetadata transactionMetadataQuery
)
{
// Arrange
var account = new Account(new UserId());
var moneyAccount = new MoneyAccountDecorator(account);
moneyAccount.Deposit(Money.Fifty).MarkAsSucceeded();
moneyAccount.Charge(Money.Ten, transactionMetadata);
// Act
var action = new Action(() => account.FindTransaction(transactionMetadataQuery));
// Assert
action.Should().Throw <InvalidOperationException>();
}
private ImmutableTransaction BuildTestTransaction(DateTime?startTime = null, TimeSpan?duration = null, TimeSpan?responseTime = null, string uri = null, string guid = null)
{
var transactionMetadata = new TransactionMetadata();
if (uri != null)
{
transactionMetadata.SetUri(uri);
}
var name = TransactionName.ForWebTransaction("foo", "bar");
var segments = Enumerable.Empty <Segment>();
var metadata = transactionMetadata.ConvertToImmutableMetadata();
startTime = startTime ?? DateTime.Now;
duration = duration ?? TimeSpan.FromSeconds(1);
guid = guid ?? Guid.NewGuid().ToString();
return(new ImmutableTransaction(name, segments, metadata, startTime.Value, duration.Value, responseTime, guid, false, false, false, 1.2f, false, string.Empty, null, _attribDefs));
}
public void AddUserAttribute_LastInWins()
{
var key = "testKey";
var valueA = "valueA";
var valueB = "valueB";
var metadata = new TransactionMetadata();
metadata.AddUserAttribute(key, valueA);
metadata.AddUserAttribute(key, valueB);
var immutableTransactionMetadata = metadata.ConvertToImmutableMetadata();
var userAttributes = immutableTransactionMetadata.UserAttributes.ToDictionary();
var result = userAttributes[key];
Assert.AreEqual(result, valueB);
}
private byte[] SerializeMetadata(TransactionMetadata metadata)
{
Messages.TransactionMetadata transactionMetadataBuilder = new Messages.TransactionMetadata();
transactionMetadataBuilder.Signatures.Add(metadata.Signatures.Select(
signature => new Messages.TransactionMetadata.Types.SignatureEvidence()
{
PublicKey = Google.Protobuf.ByteString.Unsafe.FromBytes(signature.PublicKey.ToByteArray()),
Signature = Google.Protobuf.ByteString.Unsafe.FromBytes(signature.Signature.ToByteArray())
}));
return transactionMetadataBuilder.ToByteArray();
}