blob: f841d0d671721d6a7f6ffa196f05499556dd4e51 [file] [log] [blame]
/*
* Copyright 2014, Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package io.grpc.internal;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import io.grpc.Status;
import io.grpc.internal.GrpcUtil.Http2Error;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/** Unit tests for {@link GrpcUtil}. */
@RunWith(JUnit4.class)
public class GrpcUtilTest {
@Rule public final ExpectedException thrown = ExpectedException.none();
@Test
public void http2ErrorForCode() {
// Try edge cases manually, to make the test obviously correct for important cases.
assertNull(Http2Error.forCode(-1));
assertSame(Http2Error.NO_ERROR, Http2Error.forCode(0));
assertSame(Http2Error.HTTP_1_1_REQUIRED, Http2Error.forCode(0xD));
assertNull(Http2Error.forCode(0xD + 1));
}
@Test
public void http2ErrorRoundTrip() {
for (Http2Error error : Http2Error.values()) {
assertSame(error, Http2Error.forCode(error.code()));
}
}
@Test
public void http2ErrorStatus() {
// Nothing special about this particular error, except that it is slightly distinctive.
assertSame(Status.Code.CANCELLED, Http2Error.CANCEL.status().getCode());
}
@Test
public void http2ErrorStatusForCode() {
assertSame(Status.Code.INTERNAL, Http2Error.statusForCode(-1).getCode());
assertSame(Http2Error.NO_ERROR.status(), Http2Error.statusForCode(0));
assertSame(Http2Error.HTTP_1_1_REQUIRED.status(), Http2Error.statusForCode(0xD));
assertSame(Status.Code.INTERNAL, Http2Error.statusForCode(0xD + 1).getCode());
}
@Test
public void timeoutTest() {
GrpcUtil.TimeoutMarshaller marshaller =
new GrpcUtil.TimeoutMarshaller();
// nanos
assertEquals("0n", marshaller.toAsciiString(0L));
assertEquals(0L, (long) marshaller.parseAsciiString("0n"));
assertEquals("99999999n", marshaller.toAsciiString(99999999L));
assertEquals(99999999L, (long) marshaller.parseAsciiString("99999999n"));
// micros
assertEquals("100000u", marshaller.toAsciiString(100000000L));
assertEquals(100000000L, (long) marshaller.parseAsciiString("100000u"));
assertEquals("99999999u", marshaller.toAsciiString(99999999999L));
assertEquals(99999999000L, (long) marshaller.parseAsciiString("99999999u"));
// millis
assertEquals("100000m", marshaller.toAsciiString(100000000000L));
assertEquals(100000000000L, (long) marshaller.parseAsciiString("100000m"));
assertEquals("99999999m", marshaller.toAsciiString(99999999999999L));
assertEquals(99999999000000L, (long) marshaller.parseAsciiString("99999999m"));
// seconds
assertEquals("100000S", marshaller.toAsciiString(100000000000000L));
assertEquals(100000000000000L, (long) marshaller.parseAsciiString("100000S"));
assertEquals("99999999S", marshaller.toAsciiString(99999999999999999L));
assertEquals(99999999000000000L, (long) marshaller.parseAsciiString("99999999S"));
// minutes
assertEquals("1666666M", marshaller.toAsciiString(100000000000000000L));
assertEquals(99999960000000000L, (long) marshaller.parseAsciiString("1666666M"));
assertEquals("99999999M", marshaller.toAsciiString(5999999999999999999L));
assertEquals(5999999940000000000L, (long) marshaller.parseAsciiString("99999999M"));
// hours
assertEquals("1666666H", marshaller.toAsciiString(6000000000000000000L));
assertEquals(5999997600000000000L, (long) marshaller.parseAsciiString("1666666H"));
assertEquals("2562047H", marshaller.toAsciiString(Long.MAX_VALUE));
assertEquals(9223369200000000000L, (long) marshaller.parseAsciiString("2562047H"));
assertEquals(Long.MAX_VALUE, (long) marshaller.parseAsciiString("2562048H"));
}
@Test
public void grpcUserAgent() {
assertTrue(GrpcUtil.getGrpcUserAgent("netty", null).startsWith("grpc-java-netty"));
assertTrue(GrpcUtil.getGrpcUserAgent("okhttp", "libfoo/1.0")
.startsWith("libfoo/1.0 grpc-java-okhttp"));
}
@Test
public void contentTypeShouldBeValid() {
assertTrue(GrpcUtil.isGrpcContentType(GrpcUtil.CONTENT_TYPE_GRPC));
assertTrue(GrpcUtil.isGrpcContentType(GrpcUtil.CONTENT_TYPE_GRPC + "+blaa"));
assertTrue(GrpcUtil.isGrpcContentType(GrpcUtil.CONTENT_TYPE_GRPC + ";blaa"));
}
@Test
public void contentTypeShouldNotBeValid() {
assertFalse(GrpcUtil.isGrpcContentType("application/bad"));
}
@Test
public void checkAuthority_failsOnNull() {
thrown.expect(NullPointerException.class);
GrpcUtil.checkAuthority(null);
}
@Test
public void checkAuthority_succeedsOnHostAndPort() {
String actual = GrpcUtil.checkAuthority("valid:1234");
assertEquals("valid:1234", actual);
}
@Test
public void checkAuthority_succeedsOnHost() {
String actual = GrpcUtil.checkAuthority("valid");
assertEquals("valid", actual);
}
@Test
public void checkAuthority_succeedsOnIpV6() {
String actual = GrpcUtil.checkAuthority("[::1]");
assertEquals("[::1]", actual);
}
@Test
public void checkAuthority_failsOnInvalidAuthority() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid authority");
GrpcUtil.checkAuthority("[ : : 1]");
}
@Test
public void checkAuthority_failsOnInvalidHost() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("No host in authority");
GrpcUtil.checkAuthority("bad_host");
}
@Test
public void checkAuthority_userInfoNotAllowed() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Userinfo");
GrpcUtil.checkAuthority("foo@valid");
}
@Test
public void httpStatusToGrpcStatus_messageContainsHttpStatus() {
assertTrue(GrpcUtil.httpStatusToGrpcStatus(500).getDescription().contains("500"));
}
@Test
public void httpStatusToGrpcStatus_checkAgainstSpec() {
assertEquals(Status.Code.INTERNAL, GrpcUtil.httpStatusToGrpcStatus(400).getCode());
assertEquals(Status.Code.UNAUTHENTICATED, GrpcUtil.httpStatusToGrpcStatus(401).getCode());
assertEquals(Status.Code.PERMISSION_DENIED, GrpcUtil.httpStatusToGrpcStatus(403).getCode());
assertEquals(Status.Code.UNIMPLEMENTED, GrpcUtil.httpStatusToGrpcStatus(404).getCode());
assertEquals(Status.Code.UNAVAILABLE, GrpcUtil.httpStatusToGrpcStatus(429).getCode());
assertEquals(Status.Code.UNAVAILABLE, GrpcUtil.httpStatusToGrpcStatus(502).getCode());
assertEquals(Status.Code.UNAVAILABLE, GrpcUtil.httpStatusToGrpcStatus(503).getCode());
assertEquals(Status.Code.UNAVAILABLE, GrpcUtil.httpStatusToGrpcStatus(504).getCode());
// Some other code
assertEquals(Status.Code.UNKNOWN, GrpcUtil.httpStatusToGrpcStatus(500).getCode());
// If transport is doing it's job, 1xx should never happen. But it may not do its job.
assertEquals(Status.Code.INTERNAL, GrpcUtil.httpStatusToGrpcStatus(100).getCode());
assertEquals(Status.Code.INTERNAL, GrpcUtil.httpStatusToGrpcStatus(101).getCode());
}
@Test
public void httpStatusToGrpcStatus_neverOk() {
for (int i = -1; i < 800; i++) {
assertFalse(GrpcUtil.httpStatusToGrpcStatus(i).isOk());
}
}
}