How to use parser class of io.kotest.extensions.http package

Best Kotest code snippet using io.kotest.extensions.http.parser

EagerBodyReaderTest.kt

Source:EagerBodyReaderTest.kt

...164            asRawString(Charsets.UTF_8) shouldBe body165            decodeBody() shouldHaveSameElementsAs "98".toByteArray()166            decodeBodyToString(UTF_8) shouldBe "98"167        }168        // verify that the parser stopped at the correct body ending169        stream.readBytes().toString(UTF_8) shouldBe "IGNORED"170    }171})...

OkHttp3ResourceRetrieverTest.kt

Source:OkHttp3ResourceRetrieverTest.kt

1package dev.gmetal.metador2import dev.gmetal.metador.mockserver.BASE_URL3import dev.gmetal.metador.mockserver.MOCK_WEB_SERVER_PORT4import dev.gmetal.metador.mockserver.errorMockResponse5import dev.gmetal.metador.mockserver.successMockResponse6import io.kotest.assertions.throwables.shouldThrow7import io.kotest.core.datatest.forAll8import io.kotest.core.spec.style.BehaviorSpec9import io.kotest.engine.spec.tempdir10import io.kotest.extensions.mockserver.MockServerListener11import io.kotest.matchers.shouldBe12import io.kotest.matchers.types.instanceOf13import io.mockk.mockk14import kotlinx.coroutines.test.TestCoroutineDispatcher15import org.mockserver.client.MockServerClient16import org.mockserver.configuration.ConfigurationProperties17import org.mockserver.mock.Expectation18import org.mockserver.model.ExpectationId19import org.mockserver.model.Header20import org.mockserver.model.Headers21import org.mockserver.model.HttpRequest22import org.mockserver.model.HttpRequest.request23import org.mockserver.model.HttpResponse24import org.mockserver.model.RequestDefinition25import java.net.HttpURLConnection.HTTP_INTERNAL_ERROR26import java.net.HttpURLConnection.HTTP_NOT_FOUND27class OkHttp3ResourceRetrieverTest : BehaviorSpec({28    lateinit var mockMetadorSuccess: Metador.SuccessCallback29    lateinit var mockMetadorFailure: Metador.FailureCallback30    lateinit var mockResourceParserDelegate: ResourceParserDelegate31    lateinit var resourceRetrieverInTest: OkHttp3ResourceRetriever32    val testCoroutineDispatcher = TestCoroutineDispatcher()33    fun metadorRequest(uri: String, maxSecondsCached: Int = DEFAULT_MAX_AGE_CACHE_SECONDS) =34        Metador.Request(35            uri,36            maxSecondsCached,37            mockResourceParserDelegate,38            mockMetadorSuccess,39            mockMetadorFailure40        )41    var listener: MockServerListener = listener(MockServerListener(MOCK_WEB_SERVER_PORT))42    val mockServerClient = MockServerClient("localhost", MOCK_WEB_SERVER_PORT)43    ConfigurationProperties.logLevel("DEBUG")44    ConfigurationProperties.disableSystemOut(true)45    beforeContainer {46        mockMetadorSuccess = mockk()47        mockMetadorFailure = mockk()48        mockResourceParserDelegate = mockk()49        resourceRetrieverInTest = OkHttp3ResourceRetriever(testCoroutineDispatcher)50    }51    afterContainer {52        testCoroutineDispatcher.cleanupTestCoroutines()53    }54    lateinit var currentExpections: Array<Expectation>55    afterTest {56        currentExpections.forEach { expectation ->57            mockServerClient.clear(ExpectationId().withId(expectation.id))58        }59    }60    Given("a remote resource") {61        val remoteResource = "remote_resource"62        When("it cannot be found") {63            val notFoundUrl = responseUrl(remoteResource)64            beforeTest {65                currentExpections = mockServerClient.addExpectation(66                    remoteResource,67                    errorMockResponse(HTTP_NOT_FOUND)68                )69            }70            Then("a ResourceNotFoundException is thrown") {71                val exception = shouldThrow<ResourceNotFoundException> {72                    resourceRetrieverInTest.retrieveResource(metadorRequest(notFoundUrl))73                }74                exception shouldBe instanceOf(ResourceNotFoundException::class)75            }76        }77        When("the server encounters an internal error") {78            val serverErrorUrl = responseUrl(remoteResource)79            beforeTest {80                currentExpections = mockServerClient.addExpectation(81                    remoteResource,82                    errorMockResponse(HTTP_INTERNAL_ERROR)83                )84            }85            Then("a ServerErrorException is thrown") {86                val exception = shouldThrow<ServerErrorException> {87                    resourceRetrieverInTest.retrieveResource(metadorRequest(serverErrorUrl))88                }89                exception.httpCode shouldBe HTTP_INTERNAL_ERROR90            }91        }92        When("the server returns an empty response") {93            val emptyResponseUrl = responseUrl(remoteResource)94            beforeTest {95                currentExpections = mockServerClient.addExpectation(96                    remoteResource,97                    successMockResponse(204)98                )99            }100            Then("An EmptyResponseException is thrown") {101                shouldThrow<EmptyResponseException> {102                    resourceRetrieverInTest.retrieveResource(metadorRequest(emptyResponseUrl))103                }104            }105        }106        When("the server returns any unknown 4xx response code") {107            forAll(108                ts = listOf(109                    400,110                    401,111                    402,112                    403,113                    405,114                    406,115                    407,116                    408,117                    409,118                    410,119                    411,120                    412,121                    413,122                    414,123                    415124                )125            ) { responseCode ->126                val emptyResponseUrl = responseUrl(remoteResource)127                beforeTest {128                    currentExpections = mockServerClient.addExpectation(129                        remoteResource,130                        errorMockResponse(responseCode)131                    )132                }133                Then("an UnknownNetworkException is thrown") {134                    val exception = shouldThrow<UnknownNetworkException> {135                        resourceRetrieverInTest.retrieveResource(metadorRequest(emptyResponseUrl))136                    }137                    exception shouldBe instanceOf(UnknownNetworkException::class)138                }139            }140        }141        When("the Metador.Request instructs us to bypass the cache") {142            val noCacheUrl = responseUrl(remoteResource)143            currentExpections = mockServerClient.addExpectation(144                remoteResource,145                successMockResponse(resourceBody = HTML_DOCUMENT_WITHOUT_META)146            )147            val response = resourceRetrieverInTest.retrieveResource(148                metadorRequest(149                    noCacheUrl,150                    REQUEST_FRESH_COPY151                )152            )153            Then("the resource retriever requests the resource from the network") {154                response shouldBe HTML_DOCUMENT_WITHOUT_META155                with(156                    listener.mockServer?.retrieveRecordedRequests(157                        request()158                            .withPath("/$remoteResource")159                    ) as Array<RequestDefinition>160                ) {161                    size shouldBe 1162                    (this[0] as HttpRequest).headers.getValues("Cache-Control") shouldBe listOf("no-cache")163                }164            }165        }166        When("the Metador.Request instructs us to use a cached copy if available") {167            val cachedUrl = responseUrl(remoteResource)168            currentExpections = mockServerClient.addExpectation(169                remoteResource,170                successMockResponse(171                    resourceBody = HTML_DOCUMENT_WITHOUT_META,172                    headers = Headers().withEntry(173                        Header("Cache-Control", "max-age=6000")174                    )175                )176            )177            resourceRetrieverInTest.configureCache(tempdir().absolutePath, 1024 * 1024)178            val firstResponse =179                resourceRetrieverInTest.retrieveResource(metadorRequest(cachedUrl, 100))180            val secondResponse =181                resourceRetrieverInTest.retrieveResource(metadorRequest(cachedUrl, 100))182            Then("the resource retriever will use the cached copy") {183                firstResponse shouldBe HTML_DOCUMENT_WITHOUT_META184                secondResponse shouldBe HTML_DOCUMENT_WITHOUT_META185                with(186                    listener.mockServer?.retrieveRecordedRequests(187                        request()188                            .withPath("/$remoteResource")189                    ) as Array<RequestDefinition>190                ) {191                    size shouldBe 1192                }193            }194        }195    }196})197private inline fun responseUrl(url: String) = "$BASE_URL/$url"198private fun MockServerClient.addExpectation(199    resource: String,200    toResponse: HttpResponse201): Array<Expectation> {202    return this.`when`(203        request()204            .withMethod("GET")205            .withPath("/$resource")206    ).respond(207        toResponse208    )209}...

LazyBodyReaderTest.kt

Source:LazyBodyReaderTest.kt

...174                        .with("Hello", "wow")175                        .build()176            }177        }178        // verify that the parser stopped at the correct body ending179        stream.readBytes().toString(UTF_8) shouldBe "IGNORED"180    }181})...

InputStreamChunkDecoderTest.kt

Source:InputStreamChunkDecoderTest.kt

1package rawhttp.core.body2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.matchers.collections.beEmpty4import io.kotest.matchers.should5import io.kotest.matchers.shouldBe6import org.junit.jupiter.api.Disabled7import org.junit.jupiter.api.Test8import rawhttp.core.HttpMetadataParser9import rawhttp.core.RawHttpOptions10import rawhttp.core.internal.Bool11import rawhttp.core.shouldHaveSameElementsAs12class InputStreamChunkDecoderTest {13    private val chunkedBodyParser = ChunkedBodyParser(HttpMetadataParser(RawHttpOptions.defaultInstance()))14    @Test15    fun canDecodeEmptyChunkedBody() {16        val chunkedBody = "0\r\n\r\n"17        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())18        decoderStream.readBytes() shouldHaveSameElementsAs byteArrayOf()19        decoderStream.trailer.asMap() shouldBe mapOf<String, List<String>>()20    }21    @Test22    fun canDecodeChunkedBody() {23        val chunkedBody = "4\r\nHell\r\n4\r\no wo\r\n3\r\nrld\r\n0\r\n\r\n"24        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())25        decoderStream.readBytes() shouldHaveSameElementsAs "Hello world".toByteArray()26        decoderStream.trailer.asMap() shouldBe mapOf<String, List<String>>()27    }28    @Test29    fun canDecodeLargerChunkedBody() {30        val chunkedBody = "4\r\nWiki\r\n5\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n"31        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())32        decoderStream.readBytes() shouldHaveSameElementsAs "Wikipedia in\r\n\r\nchunks.".toByteArray()33        decoderStream.trailer.asMap() shouldBe mapOf<String, List<String>>()34    }35    @Test // see issue #936    fun canDecodeChunkedBodyWithTinyChunksLikeGoogleUses() {37        val chunkedBody = "00000001\r\n_\r\n00000001;abc=def\r\n_\r\n" +38                "0000000000000000000000000000000000000000000000000000000000000001\r\n_\r\n" +39                "0004\r\nWiki\r\n0005\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0000\r\n\r\n"40        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())41        val chunkIterator = decoderStream.asIterator()42        repeat(3) { index ->43            chunkIterator.hasNext() shouldBe true44            chunkIterator.next().let {45                it.data shouldHaveSameElementsAs "_".toByteArray()46                if (index == 1)47                    it.extensions.asMap() shouldBe mapOf("ABC" to listOf("def"))48                else49                    it.extensions.asMap() shouldBe emptyMap<String, Any>()50            }51        }52        decoderStream.readBytes() shouldHaveSameElementsAs "Wikipedia in\r\n\r\nchunks.".toByteArray()53        decoderStream.trailer.asMap() shouldBe emptyMap<String, Any>()54    }55    @Test56    fun canDecodeChunkedBodyWithTrailer() {57        val chunkedBody = "2\r\n98\r\n0\r\nHello: hi there\r\nBye:true\r\nHello: wow\r\n\r\n"58        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())59        decoderStream.readBytes() shouldHaveSameElementsAs "98".toByteArray()60        decoderStream.trailer.asMap() shouldBe mapOf(61                "HELLO" to listOf("hi there", "wow"),62                "BYE" to listOf("true"))63    }64    @Test65    @Disabled("Cannot parse extensions without a value") // FIXME66    fun canDecodeChunkedBodyContainingExtensionsAndTrailer() {67        val chunkedBody = """68            4;foo=bar69            evil70            1;foo=bbb71            =72            1;fooxbazonk73            h74            1;zxczxczxc75            a76            1;yadadada77            h78            1;hrrmph79            a""".trimIndent()80        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())81        decoderStream.readBytes() shouldHaveSameElementsAs "evilhaha".toByteArray()82        decoderStream.trailer.asMap() shouldBe mapOf<String, List<String>>()83    }84    @Test85    fun canReadChunkByChunk() {86        val chunkedBody = "4\r\nHell\r\n4\r\no wo\r\n3;ext=true\r\nrld\r\n0\r\n\r\nIGNORED"87        val originalStream = chunkedBody.byteInputStream()88        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, originalStream)89        val chunk1 = decoderStream.readChunk()90        chunk1.data shouldHaveSameElementsAs "Hell".toByteArray()91        chunk1.size() shouldBe 492        chunk1.extensions.isEmpty93        val chunk2 = decoderStream.readChunk()94        chunk2.data shouldHaveSameElementsAs "o wo".toByteArray()95        chunk2.size() shouldBe 496        chunk2.extensions.isEmpty97        val chunk3 = decoderStream.readChunk()98        chunk3.data shouldHaveSameElementsAs "rld".toByteArray()99        chunk3.size() shouldBe 3100        chunk3.extensions.asMap() shouldBe mapOf("EXT" to listOf("true"))101        val lastChunk = decoderStream.readChunk()102        lastChunk.data.asList() should beEmpty()103        lastChunk.size() shouldBe 0104        decoderStream.trailer.asMap() shouldBe mapOf<String, List<String>>()105        shouldThrow<IllegalStateException> { decoderStream.readChunk() }106        originalStream.reader().readText() shouldBe "IGNORED"107    }108    @Test109    fun cannotDecodeInvalidChunkSizeWithTooManyBytes() {110        // 65 bytes long111        val chunkedBody = "00000000000000000000000000000000000000000000000000000000000000001"112        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())113        shouldThrow<java.lang.IllegalStateException> {114            decoderStream.readChunk()115        }.message shouldBe "Invalid chunk-size (too many digits)"116    }117    @Test118    fun cannotDecodeInvalidChunkSizeTooBig() {119        // too big to fit into an int120        val chunkedBody = "FFFFFFFF"121        val decoderStream = InputStreamChunkDecoder(chunkedBodyParser, chunkedBody.byteInputStream())122        shouldThrow<java.lang.IllegalStateException> {123            decoderStream.readChunk()124        }.message shouldBe "Invalid chunk-size (too big)"125    }126    @Test127    fun chunkSizeIsParsedCorrectly() {128        chunkedBodyParser.readChunkSize("0000000\n".byteInputStream(), Bool()) shouldBe 0129        chunkedBodyParser.readChunkSize("0000001\n".byteInputStream(), Bool()) shouldBe 1130        chunkedBodyParser.readChunkSize("000000A\n".byteInputStream(), Bool()) shouldBe 10131        chunkedBodyParser.readChunkSize("1000000\n".byteInputStream(), Bool()) shouldBe 16_777_216132        chunkedBodyParser.readChunkSize("abcdef\n".byteInputStream(), Bool()) shouldBe 11_259_375133        // largest allowed chunk size134        chunkedBodyParser.readChunkSize("FFFFFFF\n".byteInputStream(), Bool()) shouldBe 268_435_455135        chunkedBodyParser.readChunkSize("00000FFFFFFF\n".byteInputStream(), Bool()) shouldBe 268_435_455136    }137}...

DataParserTest.kt

Source:DataParserTest.kt

...57        |++ max. Wind: 8.0 km/h 58        |++ Niederschlag der letzten Std.: 0.0 l/mÂ² 59        |++ Niederschlag der letzten 24 Std.: 12.8 l/mÂ² 60        |++ Skilift geschlossen""".trimMargin()61    "Dataparser should be able to parse received text from the remote server" {62        val p = DataParser(data)63        p.data.shouldHaveSize(10)64        p.timestampOfData().toString().shouldBe("2015-12-25T20:50:00Z")65        p.temperature().shouldBe(6.4f)66        p.humidity().shouldBe(100f)67        p.airPressure().shouldBe(1027.4f)68        p.airPressureTrend().shouldBe("gleichbleibend")69        p.windVelocity().shouldBe(17.2f)70        p.windGust().shouldBe(29.0f)71        p.rain().shouldBe(0.0)72        p.rainLastHours().shouldBe(0.6f)73        p.isLiftOpen().shouldBeFalse()74    }75    "Dataparser should be able to recognize that the ski-lift is closed" {76        val p = DataParser(data2)77        p.data.shouldHaveSize(9)78        p.timestampOfData().toString().shouldBe("2015-12-25T20:50:00Z")79        p.temperature().shouldBe(6.4f)80        p.humidity().shouldBe(100f)81        p.airPressure().shouldBe(1027.4f)82        p.airPressureTrend().shouldBe("gleichbleibend")83        p.windVelocity().shouldBe(17.2f)84        p.windGust().shouldBe(29.0f)85        p.rain().shouldBe(0.0)86        p.rainLastHours().shouldBe(0.6f)87        p.isLiftOpen().shouldBeFalse()88    }89    "Dataparser should be able to recognize that the ski-lift is open" {90        val p = DataParser(data3)91        p.data.shouldHaveSize(10)92        p.timestampOfData().toString().shouldBe("2015-12-25T20:50:00Z")93        p.temperature().shouldBe(6.4f)94        p.humidity().shouldBe(100f)95        p.airPressure().shouldBe(1027.4f)96        p.airPressureTrend().shouldBe("gleichbleibend")97        p.windVelocity().shouldBe(17.2f)98        p.windGust().shouldBe(29.0f)99        p.rain().shouldBe(0.0)100        p.rainLastHours().shouldBe(0.6f)101        p.isLiftOpen().shouldBeTrue()102    }103    "Dataparser should be able to ignore announcements of special events" {104        val p = DataParser(data4)105        p.timestampOfData().toString().shouldBe("2021-07-26T18:50:00Z")106    }107})...

WCTTest.kt

Source:WCTTest.kt

...27import io.kotest.extensions.system.SystemEnvironmentTestListener28import io.kotest.matchers.shouldBe29import io.kotest.matchers.shouldNotBe30import net.minidev.json.JSONObject31import net.minidev.json.parser.JSONParser32import java.io.File33import java.net.URI34import kotlin.reflect.KClass35val EBSI_BEARER_TOKEN_FILE = "wct_bearer_token"36class WCTEnabled: EnabledCondition {37  override fun enabled(kclass: KClass<out Spec>): Boolean {38    return File(EBSI_BEARER_TOKEN_FILE).exists()39  }40}41@EnabledIf(WCTEnabled::class)42class WCTTest: AnnotationSpec() {43  // WCT Conformance header: 286dc8c9-15ce-4f4b-a32b-8ce5a5b7c4f544  val EBSI_WCT_ENV = "http://localhost:8080"45  val SCHEMA_ID = "https://api.preprod.ebsi.eu/trusted-schemas-registry/v1/schemas/0x14b05b9213dbe7d343ec1fe1d3c8c739a3f3dc5a59bae55eb38fa0c295124f49#"...

CompoundRtcpParserTest.kt

Source:CompoundRtcpParserTest.kt

...29import org.jitsi.rtp.rtcp.UnsupportedRtcpPacket30class CompoundRtcpParserTest : ShouldSpec() {31    override fun isolationMode(): IsolationMode? = IsolationMode.InstancePerLeaf32    private val logger = StdoutLogger()33    private val parser = CompoundRtcpParser(logger)34    private val invalidRtcpData = byteArrayOf(35        0x00, 0x00, 0x00, 0x00,36        0x00, 0x00, 0x00, 0x00,37        0x00, 0x00, 0x00, 0x00,38        0x00, 0x00, 0x00, 0x0039    )40    private val unsupportedRtcpData = org.jitsi.rtp.extensions.bytearray.byteArrayOf(41        // V=2, PT=195, length = 242        0x80, 0xC3, 0x00, 0x02,43        0x00, 0x00, 0x00, 0x00,44        0x00, 0x00, 0x00, 0x0045    )46    private val rtcpByeNoReason = RtcpHeaderBuilder(47        packetType = RtcpByePacket.PT,48        reportCount = 1,49        senderSsrc = 12345L,50        length = 151    ).build()52    init {53        context("A compound RTCP packet with invalid data") {54            context("at the beginning of the packet") {55                val packet = DummyPacket(invalidRtcpData)56                val packetInfo = PacketInfo(packet)57                should("drop the packet entirely") {58                    parser.onOutput { it shouldBe null }59                    parser.processPacket(packetInfo)60                }61            }62            context("after a valid packet") {63                val packet = DummyPacket(rtcpByeNoReason + invalidRtcpData)64                val packetInfo = PacketInfo(packet)65                should("drop the packet entirely") {66                    parser.onOutput { it shouldBe null }67                    parser.processPacket(packetInfo)68                }69            }70        }71        context("A compound RTCP packet with an unsupported RTCP type") {72            context("at the beginning of the packet") {73                val packet = DummyPacket(unsupportedRtcpData)74                val packetInfo = PacketInfo(packet)75                should("parse it as UnsupportedRtcpPacket") {76                    parser.onOutput {77                        it.packet.shouldBeInstanceOf<CompoundRtcpPacket>()78                        val compoundPacket = it.packetAs<CompoundRtcpPacket>()79                        compoundPacket.packets shouldHaveSize 180                        compoundPacket.packets[0].shouldBeInstanceOf<UnsupportedRtcpPacket>()81                    }82                    parser.processPacket(packetInfo)83                }84            }85            context("in between other supported RTCP packets") {86                val packet = DummyPacket(rtcpByeNoReason + unsupportedRtcpData + rtcpByeNoReason)87                val packetInfo = PacketInfo(packet)88                should("parse it as UnsupportedRtcpPacket") {89                    parser.onOutput {90                        it.packet.shouldBeInstanceOf<CompoundRtcpPacket>()91                        val compoundPacket = it.packetAs<CompoundRtcpPacket>()92                        compoundPacket.packets shouldHaveSize 393                        compoundPacket.packets[0].shouldBeInstanceOf<RtcpByePacket>()94                        compoundPacket.packets[1].shouldBeInstanceOf<UnsupportedRtcpPacket>()95                        compoundPacket.packets[2].shouldBeInstanceOf<RtcpByePacket>()96                    }97                    parser.processPacket(packetInfo)98                }99            }100        }101    }102    private class DummyPacket(103        buf: ByteArray104    ) : Packet(buf, 0, buf.size) {105        override fun clone(): Packet = DummyPacket(cloneBuffer(0))106    }107}...

VideoQualityLayerLookupTest.kt

Source:VideoQualityLayerLookupTest.kt

...25import org.jitsi.rtp.rtp.RtpPacket26import org.jitsi.utils.logging2.createLogger27class VideoQualityLayerLookupTest : ShouldSpec() {28    override fun isolationMode(): IsolationMode? = IsolationMode.InstancePerLeaf29    private val parser = VideoQualityLayerLookup(createLogger())30    private val vp8PacketBuf = org.jitsi.rtp.extensions.bytearray.byteArrayOf(31        // V=2,P=false,X=true,CC=0,M=false,PT=100,SeqNum=1653532        0x90, 0x64, 0x40, 0x97,33        // Timestamp: 389906844634        0xe8, 0x67, 0x10, 0x1e,35        // SSRC: 282880685336        0xa8, 0x9c, 0x2a, 0xc5,37        // 1 extension38        0xbe, 0xde, 0x00, 0x01,39        0x51, 0x00, 0x02, 0x0040    ) + org.jitsi.rtp.extensions.bytearray.byteArrayOf(41        0x00, 0x00, 0x00, 0x00,42        0x00, 0x00, 0x00, 0x00,43        0x00, 0x00, 0x00, 0x00,44        0x00, 0x00, 0x00, 0x00,45        0x00, 0x00, 0x00, 0x00,46        0x00, 0x00, 0x00, 0x0047    )48    private val vp8Packet = Vp8Packet(vp8PacketBuf, 0, vp8PacketBuf.size)49    private val packetInfo = mockk<PacketInfo>(relaxed = true) {50        every { packetAs<RtpPacket>() } returns vp8Packet51        every { packet } returns vp8Packet52    }53    init {54        context("When parsing a VP8 packet") {55            context("with no encoding signaled") {56                parser.onOutput { _ ->57                    fail("Should not forward the packet")58                }59                parser.processPacket(packetInfo)60            }61        }62    }63}...

parser

Using AI Code Generation

1val parser = Parser()2val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")3val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")4val parser = Parser()5val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")6val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")7val parser = Parser()8val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")9val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")10val parser = Parser()11val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")12val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")13val parser = Parser()14val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")15val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")16val parser = Parser()17val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")18val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!")19val parser = Parser()20val request = parser.parseRequest("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")21val response = parser.parseResponse("HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r

parser

Using AI Code Generation

1import io.kotest.extensions.http.parser.HttpParser2val parser = HttpParser()3parser.parse("GET / HTTP/1.1\r4import io.kotest.extensions.http.parser.HttpParser5val parser = HttpParser()6parser.parse("GET / HTTP/1.1\r7import io.kotest.extensions.http.parser.HttpParser8val parser = HttpParser()9parser.parse("GET / HTTP/1.1\r10import io.kotest.extensions.http.parser.HttpParser11val parser = HttpParser()12parser.parse("GET / HTTP/1.1\r13import io.kotest.extensions.http.parser.HttpParser14val parser = HttpParser()15parser.parse("GET / HTTP/1.1\r16import io.kotest.extensions.http.parser.HttpParser17val parser = HttpParser()18parser.parse("GET / HTTP/1.1\r19import io.kotest.extensions.http.parser.HttpParser20val parser = HttpParser()21parser.parse("GET / HTTP/1.1\r

parser

Using AI Code Generation

1    val parser = Parser()2    val response = parser.parseResponse("""HTTP/1.1 200 OK3<meta http-equiv="Content-type" content="text/html; charset=utf-8" />4body {5    background-color: #f0f0f2;6    margin: 0;7    padding: 0;8    font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;9    val response = Response(10        mapOf(

parser

Using AI Code Generation

1    val parser = Parser()2    val request = parser.parseRequest(requestString)3    val response = parser.parseResponse(responseString)4    request should be(request)5    response should be(response)6}

parser

Using AI Code Generation

1    }2}3fun shouldHaveStatus(status: HttpStatusCode): HttpAssertion4fun shouldHaveStatus(predicate: (HttpStatusCode) -> Boolean): HttpAssertion5fun shouldHaveHeader(name: String, value: String): HttpAssertion6fun shouldHaveHeader(name: String, predicate: (String) -> Boolean): HttpAssertion7fun shouldHaveHeaders(headers: Map<String, String>): HttpAssertion8fun shouldHaveBody(body: String): HttpAssertion9fun shouldHaveBody(predicate: (String) -> Boolean): HttpAssertion10fun shouldHaveJsonBody(body: String): HttpAssertion11fun shouldHaveJsonBody(predicate: (String) -> Boolean): HttpAssertion12fun shouldHaveJsonBody(body: Any): HttpAssertion13fun shouldHaveJsonBody(predicate: (Any) -> Boolean): HttpAssertion14fun shouldHaveJsonBody(body: JsonElement): HttpAssertion15fun shouldHaveJsonBody(predicate: (JsonElement) -> Boolean): HttpAssertion16fun shouldHaveXmlBody(body: String): HttpAssertion17fun shouldHaveXmlBody(predicate: (String) -> Boolean): HttpAssertion18fun shouldHaveXmlBody(body: Any): HttpAssertion19fun shouldHaveXmlBody(predicate: (Any) -> Boolean): HttpAssertion20fun shouldHaveXmlBody(body: XmlElement): HttpAssertion21fun shouldHaveXmlBody(predicate: (XmlElement) -> Boolean): HttpAssertion22fun shouldHaveXmlBody(body: Xml): HttpAssertion23fun shouldHaveXmlBody(predicate: (Xml) -> Boolean): HttpAssertion24fun shouldHaveTextBody(body: String): HttpAssertion25fun shouldHaveTextBody(predicate: (String) -> Boolean): HttpAssertion26fun shouldHaveTextBody(body: Any): HttpAssertion27fun shouldHaveTextBody(predicate: (Any) -> Boolean): HttpAssertion28fun shouldHaveTextBody(body: XmlElement): HttpAssertion29fun shouldHaveTextBody(predicate: (XmlElement) -> Boolean): HttpAssertion30fun shouldHaveTextBody(body: Xml): HttpAssertion31fun shouldHaveTextBody(predicate: (Xml) -> Boolean): HttpAssertion32fun shouldHaveBinaryBody(body: ByteArray): HttpAssertion33fun shouldHaveBinaryBody(predicate: (ByteArray) -> Boolean): HttpAssertion34fun shouldHaveBinaryBody(body: String): HttpAssertion35fun shouldHaveBinaryBody(predicate: (String) -> Boolean): HttpAssertion36fun shouldHaveBinaryBody(body

parser

Using AI Code Generation

1    val parser = Parser()2    val response: Response = parser.parse(responseBody)3    response.bodyAsText() shouldBe "Hello World"4}5fun `test http client with kotest matchers`() {6    response.bodyAsText() shouldBe "Hello World"7}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.