public ProducerResponse ParseFrom(KafkaBinaryReader reader)
{
var size = reader.ReadInt32();
var correlationId = reader.ReadInt32();
var topicCount = reader.ReadInt32();
var statuses = new Dictionary <TopicAndPartition, ProducerResponseStatus>();
for (var i = 0; i < topicCount; ++i)
{
var topic = reader.ReadShortString();
var partitionCount = reader.ReadInt32();
for (var p = 0; p < partitionCount; ++p)
{
var partitionId = reader.ReadInt32();
var error = reader.ReadInt16();
var offset = reader.ReadInt64();
var topicAndPartition = new TopicAndPartition(topic, partitionId);
statuses.Add(topicAndPartition, new ProducerResponseStatus
{
Error = ErrorMapper.ToError(error),
Offset = offset
});
}
}
return(new ProducerResponse(correlationId, statuses));
}
public void MapShouldReturnResponseError()
{
// Arrange
var errorCode = "code";
var errorMessage = "message";
var errorTarget = "target";
ValidationResult validationResult = new ValidationResult();
validationResult.ServiceError = ServiceError.ResourceNotFound;
validationResult.Errors = new List <Failure>()
{
new Failure()
{
Code = errorCode, Message = errorMessage, Target = errorTarget
}
};
var errorMapper = new ErrorMapper();
// Act
var result = errorMapper.Map(validationResult);
// Assert
result.Should().BeOfType <ResponseError>();
result.Error.Code.Should().Be(ServiceError.ResourceNotFound.Code);
result.Error.Message.Should().Be(ServiceError.ResourceNotFound.Message);
result.Error.Details[0].Code.Should().Be(errorCode);
result.Error.Details[0].Message.Should().Be(errorMessage);
result.Error.Details[0].Target.Should().Be(errorTarget);
}
public static void OnError <T>(HttpResponse response, T handler, ErrorMapper <T> errorMapper = null) where T : IBaseNetworkErrorHandler
{
if (response.Request.CompletionState == HttpRequestState.TIMEOUT)
{
handler.onRequestTimeOut();
return;
}
if (response.StatusCode == HttpStatusCode.Unknown || string.IsNullOrEmpty(response.Text))
{
handler.onGeneralNetworkError();
return;
}
try
{
ErrorResponse errorResponse = Service.Get <JsonService>().Deserialize <ErrorResponse>(response.Text);
NetworkErrorType code = (NetworkErrorType)errorResponse.code;
bool flag = false;
NetworkErrorType networkErrorType = code;
if (networkErrorType == NetworkErrorType.INVALID_SUBSCRIPTION)
{
Service.Get <EventDispatcher>().DispatchEvent(default(NetworkErrors.InvalidSubscriptionError));
flag = true;
}
if (!(errorMapper?.Invoke(code, handler) ?? false) && !flag)
{
handler.onGeneralNetworkError();
}
}
catch (Exception)
{
handler.onGeneralNetworkError();
}
}
public void ConstructorShouldSucceed()
{
// Act
var obj = new ErrorMapper();
// Assert
obj.Should().NotBeNull();
}
static Application()
{
OS = GetOS();
ExitWithLastWindow = true;
contentProvider = NoopContentProvider.Instance;
uriWatcher = NoopUriWatcher.Instance;
OpenWindows = new WindowCollection();
ErrorMapper = new ErrorMapper();
}
internal static PartitionData ParseFrom(KafkaBinaryReader reader)
{
var partition = reader.ReadInt32();
var error = reader.ReadInt16();
var highWatermark = reader.ReadInt64();
var messageSetSize = reader.ReadInt32();
var bufferedMessageSet = BufferedMessageSet.ParseFrom(reader, messageSetSize, partition);
return(new PartitionData(partition, ErrorMapper.ToError(error), bufferedMessageSet));
}
public void MapShouldReturnNull()
{
// Arrange
ValidationResult validationResult = new ValidationResult();
var errorMapper = new ErrorMapper();
// Act
var result = errorMapper.Map(validationResult);
// Assert
result.Should().BeNull();
}
public void Save_Error_ValuesIncrement()
{
ErrorMapper errorMapper = new ErrorMapper(this.client, this.database);
Guid applicationId = Guid.NewGuid();
Guid deviceId = Guid.NewGuid();
ErrorSummary expected = new ErrorSummary()
{
ApplicationId = applicationId,
Count = 2,
Date = date,
PlatformId = platform,
Version = version,
ScreenErrors = new List <Aggregate <string> >()
{
new Aggregate <string>()
{
Key = "someScreen",
Count = 2
}
}
};
ErrorSummary summary = new ErrorSummary()
{
ApplicationId = applicationId,
Count = 1,
Date = date,
PlatformId = platform,
Version = version,
ScreenErrors = new List <Aggregate <string> >()
{
new Aggregate <string>("someScreen")
}
};
errorMapper.Save(summary);
errorMapper.Save(summary);
IMongoQuery query = Query.And
(
Query <ErrorSummary> .EQ <DateTime>(mem => mem.Date, date),
Query <ErrorSummary> .EQ <Guid>(mem => mem.ApplicationId, applicationId),
Query <ErrorSummary> .EQ <string>(mem => mem.Version, version),
Query <ErrorSummary> .EQ <PlatformType>(mem => mem.PlatformId, platform)
);
ErrorSummary actual = this.GetCollection <ErrorSummary>().FindOne(query);
actual.ShouldHave().AllPropertiesBut(x => x.Id)
.IncludingNestedObjects().EqualTo(expected);
}
internal static TopicMetadata ParseFrom(KafkaBinaryReader reader, Dictionary <int, Broker> brokers)
{
var errorCode = reader.ReadInt16();
var topic = BitWorks.ReadShortString(reader, AbstractRequest.DefaultEncoding);
var numPartitions = reader.ReadInt32();
var partitionsMetadata = new List <PartitionMetadata>();
for (var i = 0; i < numPartitions; i++)
{
partitionsMetadata.Add(PartitionMetadata.ParseFrom(reader, brokers));
}
return(new TopicMetadata(topic, partitionsMetadata, ErrorMapper.ToError(errorCode)));
}
public void ErrorMapper_Can_MapManyErrors()
{
var fixture = new Fixture();
var errors = fixture.CreateMany <PubgError>();
var errorJson = JsonConvert.SerializeObject(errors);
string json = $@"{{
""data"": [],
""included"" : [],
""errors"": {errorJson}
}}";
var mappedErrors = ErrorMapper.MapErrors(json);
mappedErrors.Should().NotBeNullOrEmpty();
Assert.All(mappedErrors, error => errors.Contains(error));
}
public ArgumentValidationBuilder UseErrorMapper(ErrorMapper errorMapper)
{
if (options.ErrorMapper is null)
{
options.ErrorMapper = errorMapper;
}
else
{
var previousErrorMapper = options.ErrorMapper;
options.ErrorMapper = (builder, context) =>
{
previousErrorMapper(builder, context);
errorMapper(builder, context);
};
}
return(this);
}
public void ErrorMapper_Can_MapError()
{
var fixture = new Fixture();
var error = fixture.Create <PubgError>();
var errorJson = JsonConvert.SerializeObject(error);
string json = $@"{{
""data"": [],
""included"" : [],
""errors"": [
{errorJson}
]
}}";
var mappedErrors = ErrorMapper.MapErrors(json);
mappedErrors.Should().NotBeNullOrEmpty();
var mappedError = mappedErrors.First();
mappedError.Should().BeEquivalentTo(error);
}
protected HttpResponseMessage ErrorResponse(string message, HttpStatusCode httpStatusCode)
{
return(ErrorMapper.ReturnError(message, HttpStatusCode.BadRequest));
}
public void GetBytesValidStructure()
{
string topicName = "topic";
int correlationId = 1;
string clientId = "TestClient";
short requiredAcks = 5;
int ackTimeout = 345;
var partition = 2;
short error = 0;
var payload = Encoding.UTF8.GetBytes("testMessage");
BufferedMessageSet messageSet = new BufferedMessageSet(new List <Message>()
{
new Message(payload)
}, 0);
var partitionData = new PartitionData(partition, ErrorMapper.ToError(error), messageSet);
var topicData = new TopicData(topicName, new List <PartitionData>()
{
partitionData
});
var request = new ProducerRequest(correlationId, clientId, requiredAcks, ackTimeout, new List <TopicData>()
{
topicData
});
int requestSize = 2 + //request type id
2 + //versionId
4 + //correlation id
request.GetShortStringWriteLength(clientId) + // actual client id
2 + //required acks
4 + //ack timeout
4 + //data count
//=== data part
request.GetShortStringWriteLength(topicName) + //topic
4 + //partition data count
4 + //partition id
4 + //messages set size
messageSet.SetSize;
var ms = new MemoryStream();
request.WriteTo(ms);
byte[] bytes = ms.ToArray();
Assert.IsNotNull(bytes);
// add 4 bytes for the length of the message at the beginning
Assert.AreEqual(requestSize + 4, bytes.Length);
// first 4 bytes = the message length
Assert.AreEqual(requestSize, BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Take(4).ToArray <byte>()), 0));
// next 2 bytes = the request type
Assert.AreEqual((short)RequestTypes.Produce, BitConverter.ToInt16(BitWorks.ReverseBytes(bytes.Skip(4).Take(2).ToArray <byte>()), 0));
// next 2 bytes = the version id
Assert.AreEqual((short)ProducerRequest.CurrentVersion, BitConverter.ToInt16(BitWorks.ReverseBytes(bytes.Skip(6).Take(2).ToArray <byte>()), 0));
// next 2 bytes = the correlation id
Assert.AreEqual(correlationId, BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Skip(8).Take(4).ToArray <byte>()), 0));
// next 2 bytes = the client id length
Assert.AreEqual((short)clientId.Length, BitConverter.ToInt16(BitWorks.ReverseBytes(bytes.Skip(12).Take(2).ToArray <byte>()), 0));
// next few bytes = the client id
Assert.AreEqual(clientId, Encoding.ASCII.GetString(bytes.Skip(14).Take(clientId.Length).ToArray <byte>()));
// next 2 bytes = the required acks
Assert.AreEqual((short)requiredAcks, BitConverter.ToInt16(BitWorks.ReverseBytes(bytes.Skip(14 + clientId.Length).Take(2).ToArray <byte>()), 0));
// next 4 bytes = the ack timeout
Assert.AreEqual(ackTimeout, BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Skip(16 + clientId.Length).Take(4).ToArray <byte>()), 0));
// next 4 bytes = the data count
Assert.AreEqual(1, BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Skip(20 + clientId.Length).Take(4).ToArray <byte>()), 0));
// next 2 bytes = the tppic length
Assert.AreEqual((short)topicName.Length, BitConverter.ToInt16(BitWorks.ReverseBytes(bytes.Skip(24 + clientId.Length).Take(2).ToArray <byte>()), 0));
// next few bytes = the topic
Assert.AreEqual(topicName, Encoding.ASCII.GetString(bytes.Skip(26 + clientId.Length).Take(topicName.Length).ToArray <byte>()));
// next 4 bytes = the partition data count
Assert.AreEqual(topicData.PartitionData.Count(), BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Skip(26 + clientId.Length + topicName.Length).Take(4).ToArray <byte>()), 0));
// next 4 bytes = the partition
Assert.AreEqual(partition, BitConverter.ToInt32(BitWorks.ReverseBytes(bytes.Skip(30 + clientId.Length + topicName.Length).Take(4).ToArray <byte>()), 0));
// skipping MessageSet check - this could be done separately in another unit test
}
public ValidationBuilder UseErrorMapper(ErrorMapper errorMapper)
{
options.ErrorMapper = errorMapper;
return(this);
}
public ConnectorBase(ConnectorLocator locator)
{
this.locator = locator;
this.errorMapper = new ErrorMapper();
}
