This repository is the official gRPC implementation for .NET (grpc-dotnet), providing a comprehensive set of libraries for building gRPC services and clients on ASP.NET Core. It includes server-side integration via `Grpc.AspNetCore.Server` with full support for unary, server-streaming, client-streaming, and duplex streaming calls, as well as client-side libraries (`Grpc.Net.Client`, `Grpc.Net.ClientFactory`) that leverage `HttpClient` and DI. The codebase also covers gRPC-Web (both server middleware and client handler), health checks, server reflection, load balancing, retry/hedging policies, compression, interceptors, and a CLI tool (`dotnet-grpc`) for managing protobuf references. The architecture is modular, with clear separation of concerns: core abstractions in `Grpc.Core.Api`, shared utilities in `Grpc.Net.Common`, and platform-specific implementations. Extensive unit and functional tests, performance benchmarks, and interop test assets ensure correctness and performance across .NET versions and platforms.
Axios is a promise-based HTTP client for both browser and Node.js environments. It provides a rich feature set including request/response interceptors, automatic JSON serialization, cancellation via AbortController or legacy CancelToken, progress tracking, CSRF protection, and support for multiple adapters (XHR, HTTP, Fetch). The library is designed with a modular architecture: core classes (Axios, AxiosError, AxiosHeaders, InterceptorManager) handle request lifecycle and configuration merging, while platform-specific adapters handle actual network I/O. A comprehensive set of helper utilities (composeSignals, progressEventReducer, sanitizeHeaderValue, etc.) implement reusable patterns for signal composition, throttled progress events, header injection prevention, and more. The codebase is extensively tested across runtimes (Node, browser, Bun, Deno) and includes security hardening against prototype pollution, SSRF, and CRLF injection. While primarily a library for other applications, its architecture demonstrates strong separation of concerns and many components are independently reusable.
RestSharp is a mature .NET HTTP client library that wraps HttpClient into a fluent request/response API. It is not a standalone application; it ships as NuGet packages consumed by other projects. The core RestClient handles execution through an async pipeline: interceptors, authenticators, request content construction, cookie containers, redirect handling, and response deserialization. RestRequest models parameters (query, header, body, URL segments, cookies, files) and is built fluently through extension methods. Responses are RestResponse<T> with error aggregation and throw helpers, making failure handling explicit and consistent. The architecture is modular: a core library plus optional serializer packages for Newtonsoft.Json, System.Text.Json, XML, and CsvHelper, a DI integration package for Microsoft dependency injection, and a Roslyn source generator that produces immutable and clone variants of configuration types. Authentication is pluggable via IAuthenticator, with built-in Basic, JWT, OAuth1 signature generation, and OAuth2 client-credentials/refresh-token/token authenticators. Serialization is managed by a registry keyed by data format and content type, with automatic body sniffing between JSON and XML. The codebase multi-targets netstandard2.0, net471, net48, net8.0, net9.0, and net10.0, and includes extensive unit and WireMock-based integration tests, benchmarks, and versioned Docusaurus documentation. Code quality is strong: clean separation of concerns, extensive use of extension methods for ergonomics, custom source generation for option immutability, and a comprehensive test suite covering OAuth1 official vectors, redirect behavior, cookies, serializer edge cases, and interceptor ordering. Some legacy surface remains (obsolete hooks, polyfills for old TFMs), but the project tracks current .NET releases and is actively maintained. This is a well-crafted library that remains one of the standard HTTP client abstractions in the .NET ecosystem.
Kaspresso is a comprehensive Android UI testing framework built on top of Espresso (via Kakao) and UI Automator (via Kautomator), providing a Kotlin DSL for writing stable, readable tests. It offers extensive built-in reliability mechanisms: flaky safety (automatic retries with configurable timeouts), auto-scroll fallback, system dialog handling, and element reloading. The framework includes a modular interceptor architecture for customizing test behavior, device manipulation APIs (network, location, phone, permissions, logcat, screenshots, video recording), and integration with Allure for reporting and Jetpack Compose for modern UI testing. Additionally, it provides an ADB server for executing shell commands on the device and a command-line tool for generating page objects from UI dumps. The codebase is well-structured with multi-module Gradle projects, convention plugins, and extensive sample apps demonstrating real-world usage.
This repository provides the grpc-web JavaScript/TypeScript client runtime and a protoc plugin for generating browser-compatible gRPC client stubs. It enables browser clients to communicate with gRPC services through an HTTP/1.1 proxy (Envoy or grpcwebproxy) by implementing the gRPC-Web protocol. The codebase includes a runtime library (npm package `grpc-web`) with support for unary and server-streaming calls, interceptors, metadata, deadlines, and two wire formats (grpcwebtext, grpcweb). The protoc plugin (`protoc-gen-grpc-web`) is a C++ binary that outputs client code in Closure, CommonJS, or TypeScript styles. Examples and interop tests demonstrate end-to-end usage with Node.js backends, Envoy proxy, and browser clients. The project is now in maintenance mode (no new features) with several drift risks: dual implementation (Closure JS and TypeScript), archived dependencies (Closure library, Protobuf JS), and incomplete TypeScript migration. Despite this, the core components are well-architected and the gRPC-Web stream parser and interceptor pattern are reusable.