Beispiel #1
0
        public void LeaveGroupResponse(
            [Values(
                 ErrorResponseCode.None,
                 ErrorResponseCode.OffsetMetadataTooLarge
                 )] ErrorResponseCode errorCode)
        {
            var response = new LeaveGroupResponse(errorCode);

            response.AssertCanEncodeDecodeResponse(0);
        }
        public void LeaveGroupResponse(
            [Values(
                 ErrorCode.NONE,
                 ErrorCode.OFFSET_METADATA_TOO_LARGE
                 )] ErrorCode errorCode)
        {
            var response = new LeaveGroupResponse(errorCode);

            response.AssertCanEncodeDecodeResponse(0);
        }
Beispiel #3
0
        public void LeaveGroupResponse()
        {
            var response1 = new LeaveGroupResponse();

            Stream binary1 = new MemoryStream();

            response1.Serialize(binary1);

            binary1.Seek(0L, SeekOrigin.Begin);
            var response2 = new LeaveGroupResponse();

            response2.Deserialize(binary1);

            var compareLogic = new CompareLogic();
            var result       = compareLogic.Compare(response1, response2);

            Assert.True(result.AreEqual);

            Stream binary2 = new MemoryStream();

            response2.Serialize(binary2);
            Assert.Equal(binary1.Length, binary2.Length);

            using (var stream1 = new MemoryStream())
                using (var stream2 = new MemoryStream()) {
                    binary1.Seek(0L, SeekOrigin.Begin);
                    binary1.CopyTo(stream1);

                    binary2.Seek(0L, SeekOrigin.Begin);
                    binary2.CopyTo(stream2);

                    Assert.Equal(stream1.Length, stream2.Length);
                    stream1.Seek(0L, SeekOrigin.Begin);
                    var bytes1 = stream1.ToArray();

                    stream2.Seek(0L, SeekOrigin.Begin);
                    var bytes2 = stream2.ToArray();
                    Assert.Equal(bytes1.Length, bytes2.Length);

                    for (int i = 0; i < bytes1.Length; i++)
                    {
                        Assert.Equal(bytes1[i], bytes2[i]);
                    }
                }
        }
Beispiel #4
0
        public async override Task <LeaveGroupResponse> LeaveGroup(LeaveGroupRequest request, ServerCallContext context)
        {
            try
            {
                var result = new LeaveGroupResponse {
                    Success = true
                };
                var userIdentifier = GetUserIdentifier(context);
                var user           = await _groupStore.GetUser(userIdentifier);

                if (user != null)
                {
                    var userGroup = await _groupStore.GetUserGroup(user.Id, request.Id);

                    if (userGroup != null)
                    {
                        await _groupStore.RemoveUserGroup(userGroup);
                    }
                    else
                    {
                        result.Success = false;
                        result.Message = "User is not connected to group";
                    }
                }
                else
                {
                    result.Success = false;
                    result.Message = "User does not exist";
                }
                return(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return(new LeaveGroupResponse
                {
                    Success = false,
                    Message = ex.Message
                });
            }
        }
Beispiel #5
0
        private static bool TryEncodeResponse(IKafkaWriter writer, IRequestContext context, LeaveGroupResponse response)
        {
            if (response == null)
            {
                return(false);
            }

            writer.Write(response.error_code);
            writer.Write(response.error_code);
            return(true);
        }