Merge branch 'main' into resolve-issue-375

README.md

@@ -127,6 +127,7 @@ API Dash currently supports API integration code generation for the following la
 | ---------------------- | ------------- | ------- |
 | cURL                   |               |         |
 | HAR                    |               |         |
+| C#                     | `RestSharp`   |         |
 | Dart                   | `http`        |         |
 | Dart                   | `dio`         |         |
 | Go                     | `net/http`    |         |
@@ -137,6 +138,8 @@ API Dash currently supports API integration code generation for the following la
 | Python                 | `requests`    |         |
 | Python                 | `http.client` |         |
 | Kotlin                 | `okhttp3`     |         |
+| Ruby                   | `faraday`     |         |
+| Ruby                   | `net/http`    |         |
 | Rust                   | `reqwest`     |         |
 | Rust                   | `ureq`        |         |
 | Rust                   | `Actix Client` |         |

lib/codegen/codegen.dart

@@ -1,6 +1,7 @@
 import 'package:apidash/models/models.dart' show RequestModel;
 import 'package:apidash/consts.dart';
 import 'package:apidash/utils/utils.dart' show getNewUuid;
+import 'csharp/rest_sharp.dart';
 import 'dart/http.dart';
 import 'dart/dio.dart';
 import 'go/http.dart';
@@ -9,6 +10,8 @@ import 'php/guzzle.dart';
 import 'php/curl.dart';
 import 'python/http_client.dart';
 import 'python/requests.dart';
+import 'ruby/faraday.dart';
+import 'ruby/net_http.dart';
 import 'rust/actix.dart';
 import 'rust/curl_rust.dart';
 import 'rust/reqwest.dart';
@@ -73,6 +76,10 @@ class Codegen {
             .getCode(rM, boundary: boundary ?? getNewUuid());
       case CodegenLanguage.pythonRequests:
         return PythonRequestsCodeGen().getCode(rM, boundary: boundary);
+      case CodegenLanguage.rubyFaraday:
+        return RubyFaradayCodeGen().getCode(rM);
+      case CodegenLanguage.rubyNetHttp:
+        return RubyNetHttpCodeGen().getCode(rM);
       case CodegenLanguage.rustActix:
         return RustActixCodeGen().getCode(rM, boundary: boundary);
       case CodegenLanguage.rustCurl:
@@ -85,6 +92,8 @@ class Codegen {
         return PhpGuzzleCodeGen().getCode(rM);
       case CodegenLanguage.phpCurl:
         return PHPcURLCodeGen().getCode(rM);
+      case CodegenLanguage.cSharpRestSharp:
+        return CSharpRestSharp().getCode(rM);
     }
   }
 }

lib/codegen/csharp/rest_sharp.dart

@@ -0,0 +1,197 @@
+import 'dart:convert';
+
+import 'package:apidash/consts.dart';
+import 'package:jinja/jinja.dart' as jj;
+import '../../models/request_model.dart';
+import '../../extensions/extensions.dart';
+import '../../utils/http_utils.dart';
+
+class CSharpRestSharp {
+  String kStringImports = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+
+""";
+
+  String kStringInit = """
+class Program
+{
+  static async Task Main(){
+    try{
+""";
+
+  String kInitClientTemplate = """
+      const String _baseUrl = "{{baseUrl}}";
+      var client = new RestClient(_baseUrl);
+
+
+""";
+
+  String kMethodTypeTemplate = """
+      var request = new RestRequest("{{path}}", Method.{{method}});
+
+
+""";
+
+  String kTemplateParams = """
+      request.AddQueryParameter("{{param}}", "{{value}}");
+
+""";
+
+  String kTemplateHeaders = """
+      request.AddHeader("{{header}}", "{{value}}");
+
+""";
+
+  String kTemplateFormData = """
+      {% if type == "text" -%}
+      request.AddParameter("{{name}}", "{{value}}", ParameterType.GetOrPost);
+{% else -%}
+       request.AddFile("{{name}}", "{{value}}", options: options);
+{% endif -%}
+""";
+
+  String kStringFormDataOption = """
+      request.AlwaysMultipartFormData = true;
+""";
+
+  String kStringFormdataFileOption = """
+      var options = new FileParameterOptions
+      {
+          DisableFilenameEncoding = true
+      };
+""";
+
+  String kTemplateJsonData = """
+      var jsonBody = new {{jsonData}};
+      request.AddJsonBody(jsonBody);
+
+
+""";
+
+  String kTemplateTextData = """
+      var textBody = {{textData}};
+      request.AddStringBody(textBody, ContentType.Plain);
+
+
+""";
+
+  String kStringEnd = """
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+  String? getCode(RequestModel requestModel) {
+    try {
+      String result = "";
+      var rec = getValidRequestUri(
+        requestModel.url,
+        requestModel.enabledRequestParams,
+      );
+      Uri? uri = rec.$1;
+      if (uri != null) {
+        jj.Template kNodejsImportTemplate = jj.Template(kStringImports);
+        String importsData = kNodejsImportTemplate.render();
+        result += importsData;
+
+        result += kStringInit;
+
+        jj.Template templateInitClient = jj.Template(kInitClientTemplate);
+        String initClient = templateInitClient
+            .render({"baseUrl": "${uri.scheme}://${uri.authority}"});
+        result += initClient;
+
+        jj.Template templateMethodType = jj.Template(kMethodTypeTemplate);
+        String methodType = templateMethodType.render({
+          "path": uri.path,
+          "method": requestModel.method.name.capitalize(),
+        });
+        result += methodType;
+
+        if (uri.hasQuery) {
+          var params = uri.queryParameters;
+          if (params.isNotEmpty) {
+            jj.Template templateParams = jj.Template(kTemplateParams);
+            String paramsResult = "";
+            for (var item in params.entries) {
+              paramsResult += templateParams
+                  .render({"param": item.key, "value": item.value});
+            }
+            result += "$paramsResult\n";
+          }
+        }
+
+        var headersList = requestModel.enabledRequestHeaders;
+        if (headersList != null ||
+            requestModel.hasJsonData ||
+            requestModel.hasTextData) {
+          var headers = requestModel.enabledHeadersMap;
+          if (requestModel.hasJsonData || requestModel.hasTextData) {
+            headers[kHeaderContentType] =
+                requestModel.requestBodyContentType.header;
+          }
+          if (headers.isNotEmpty) {
+            jj.Template templateHeaders = jj.Template(kTemplateHeaders);
+            String headersResult = "";
+            for (var item in headers.entries) {
+              headersResult += templateHeaders
+                  .render({"header": item.key, "value": item.value});
+            }
+            result += "$headersResult\n";
+          }
+        }
+
+        if (requestModel.hasFormData) {
+          jj.Template templateFormData = jj.Template(kTemplateFormData);
+          String formDataResult = "";
+          for (var data in requestModel.formDataMapList) {
+            formDataResult += templateFormData.render({
+              "name": data["name"],
+              "value": data["value"],
+              "type": data["type"]
+            });
+          }
+          result += kStringFormDataOption;
+          if (requestModel.hasFileInFormData) {
+            result += kStringFormdataFileOption;
+          }
+          result += "$formDataResult\n";
+        }
+
+        if (requestModel.hasJsonData) {
+          var templateJsonData = jj.Template(kTemplateJsonData);
+          Map<String, dynamic> bodyData =
+              json.decode(requestModel.requestBody!);
+          List<String> jsonArr = [];
+
+          bodyData.forEach((key, value) {
+            jsonArr += ["$key = \"$value\""];
+          });
+          String jsonDataResult = "{\n${jsonArr.join(",\n")}\n}";
+
+          result += templateJsonData.render({"jsonData": jsonDataResult});
+        }
+
+        if (requestModel.hasTextData) {
+          jj.Template templateTextData = jj.Template(kTemplateTextData);
+          result += templateTextData
+              .render({"textData": jsonEncode(requestModel.requestBody)});
+        }
+
+        result += kStringEnd;
+      }
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/codegen/java/async_http_client.dart

@@ -148,9 +148,9 @@ public class Main {
       // especially sets up Content-Type header if the request has a body
       // and Content-Type is not explicitely set by the developer
       if (hasBody &&
-          !requestModel.enabledHeadersMap.containsKey('Content-Type')) {
+          !requestModel.enabledHeadersMap.containsKey(kHeaderContentType)) {
         result += templateRequestHeader
-            .render({"name": 'Content-Type', "value": contentType});
+            .render({"name": kHeaderContentType, "value": contentType});
       }
 
       // setting up rest of the request headers

lib/codegen/js/axios.dart

@@ -90,7 +90,7 @@ axios(config)
           m[i["name"]] = i["value"];
         }
         if (requestModel.hasFormData) {
-          m[kHeaderContentType] = 'multipart/form-data';
+          m[kHeaderContentType] = ContentType.formdata.header;
         }
         result += templateHeader
             .render({"headers": padMultilineString(kEncoder.convert(m), 2)});

lib/codegen/js/fetch.dart

@@ -99,7 +99,7 @@ fetch(url, options)
         var m = {};
         for (var i in headers) {
           // fetch can automatically add the Content-Type header when FormData is passed as body
-          if (i["name"] == "Content-Type" && requestModel.hasFormData) {
+          if (i["name"] == kHeaderContentType && requestModel.hasFormData) {
             continue;
           }
           m[i["name"]] = i["value"];

lib/codegen/php/curl.dart

@@ -98,7 +98,6 @@ echo $response;
   String? getCode(RequestModel requestModel) {
     try {
       String result = "";
-      bool hasHeaders = false;
       bool hasQuery = false;
       bool hasBody = false;
 

lib/codegen/php/guzzle.dart

@@ -107,7 +107,7 @@ echo \$res->getBody();
           headersString += "\t\t\t\t'$key' => '$value', \n";
         });
         if (requestModel.hasFormData) {
-          m['Content-Type'] = 'multipart/form-data';
+          m[kHeaderContentType] = ContentType.formdata.header;
         }
         headersString = headersString.substring(
             0, headersString.length - 2); // Removing trailing comma and space

lib/codegen/ruby/faraday.dart

@@ -0,0 +1,182 @@
+import 'package:apidash/consts.dart';
+import 'package:jinja/jinja.dart' as jj;
+import 'package:apidash/utils/utils.dart' show getValidRequestUri;
+import 'package:apidash/utils/http_utils.dart' show stripUriParams;
+
+import 'package:apidash/models/models.dart' show RequestModel;
+
+// Note that delete is a special case in Faraday as API Dash supports request
+// body inside delete reqest, but Faraday does not. Hence we need to manually
+// setup request body for delete request and add that to request.
+//
+// Refer https://lostisland.github.io/faraday/#/getting-started/quick-start?id=get-head-delete-trace
+class RubyFaradayCodeGen {
+  final String kStringFaradayRequireStatement = """
+require 'uri'
+require 'faraday'
+""";
+
+  final String kStringFaradayMultipartRequireStatement = '''
+require 'faraday/multipart'
+''';
+
+  final String kTemplateRequestUrl = """
+
+REQUEST_URL = URI("{{ url }}")
+
+
+""";
+
+  final String kTemplateBody = """
+PAYLOAD = <<HEREDOC
+{{ body }}
+HEREDOC
+
+
+""";
+
+  final String kTemplateFormParamsWithFile = """
+PAYLOAD = {
+{% for param in params %}{% if param.type == "text" %}  "{{ param.name }}" => Faraday::Multipart::ParamPart.new("{{ param.value }}", "text/plain"),
+{% elif param.type == "file" %}  "{{ param.name }}" => Faraday::Multipart::FilePart.new("{{ param.value }}", "application/octet-stream"),{% endif %}{% endfor %}
+}
+
+
+""";
+
+  final String kTemplateFormParamsWithoutFile = """
+PAYLOAD = URI.encode_www_form({\n{% for param in params %}  "{{ param.name }}" => "{{ param.value }}",\n{% endfor %}})\n\n
+""";
+
+  final String kTemplateConnection = """
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter{% if hasFile %}\n  faraday.request :multipart{% endif %}
+end
+
+
+""";
+
+  final String kTemplateRequestStart = """
+response = conn.{{ method|lower }}(REQUEST_URL{% if doesMethodAcceptBody and containsBody %}, PAYLOAD{% endif %}) do |req|
+
+""";
+
+  final String kTemplateRequestParams = """
+  req.params = {
+{% for key, val in params %}    "{{ key }}" => "{{ val }}",\n{% endfor %}  }
+
+""";
+
+  final String kTemplateRequestHeaders = """
+  req.headers = {
+{% for key, val in headers %}    "{{ key }}" => "{{ val }}",\n{% endfor %}  }
+
+""";
+
+  final String kStringDeleteRequestBody = """
+  req.body = PAYLOAD
+""";
+
+  final String kStringRequestEnd = """
+end
+
+""";
+
+  final String kStringResponse = """
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+
+  String? getCode(
+    RequestModel requestModel,
+  ) {
+    try {
+      String result = "";
+
+      var rec = getValidRequestUri(
+        requestModel.url,
+        requestModel.enabledRequestParams,
+      );
+
+      Uri? uri = rec.$1;
+
+      if (uri == null) {
+        return "";
+      }
+
+      var url = stripUriParams(uri);
+
+      result += kStringFaradayRequireStatement;
+      if (requestModel.hasFormDataContentType &&
+          requestModel.hasFileInFormData) {
+        result += kStringFaradayMultipartRequireStatement;
+      }
+
+      var templateRequestUrl = jj.Template(kTemplateRequestUrl);
+      result += templateRequestUrl.render({"url": url});
+
+      if (requestModel.hasFormData) {
+        jj.Template payload;
+        if (requestModel.hasFileInFormData) {
+          payload = jj.Template(kTemplateFormParamsWithFile);
+        } else {
+          payload = jj.Template(kTemplateFormParamsWithoutFile);
+        }
+        result += payload.render({"params": requestModel.formDataMapList});
+      } else if (requestModel.hasJsonData || requestModel.hasTextData) {
+        var templateBody = jj.Template(kTemplateBody);
+        result += templateBody.render({
+          "body": requestModel.requestBody,
+        });
+      }
+
+      // creating faraday connection for request
+      var templateConnection = jj.Template(kTemplateConnection);
+      result += templateConnection.render({
+        "hasFile": requestModel.hasFormDataContentType &&
+            requestModel.hasFileInFormData
+      });
+
+      // start of the request sending
+      var templateRequestStart = jj.Template(kTemplateRequestStart);
+      result += templateRequestStart.render({
+        "method": requestModel.method.name,
+        "doesMethodAcceptBody":
+            kMethodsWithBody.contains(requestModel.method) &&
+                requestModel.method != HTTPVerb.delete,
+        "containsBody": requestModel.hasBody,
+      });
+
+      var headers = requestModel.enabledHeadersMap;
+      if (requestModel.hasBody && !requestModel.hasContentTypeHeader) {
+        if (requestModel.hasJsonData || requestModel.hasTextData) {
+          headers[kHeaderContentType] =
+              requestModel.requestBodyContentType.header;
+        }
+      }
+
+      if (headers.isNotEmpty) {
+        var templateRequestHeaders = jj.Template(kTemplateRequestHeaders);
+        result += templateRequestHeaders.render({"headers": headers});
+      }
+
+      if (uri.hasQuery) {
+        var params = uri.queryParameters;
+        if (params.isNotEmpty) {
+          var templateRequestParams = jj.Template(kTemplateRequestParams);
+          result += templateRequestParams.render({"params": params});
+        }
+      }
+
+      if (requestModel.hasBody && requestModel.method == HTTPVerb.delete) {
+        result += kStringDeleteRequestBody;
+      }
+
+      result += kStringRequestEnd;
+      result += kStringResponse;
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/codegen/ruby/net_http.dart

@@ -0,0 +1,118 @@
+import 'package:jinja/jinja.dart' as jj;
+import 'package:apidash/utils/utils.dart' show getValidRequestUri;
+import 'package:apidash/models/models.dart' show RequestModel;
+import '../../extensions/extensions.dart';
+import 'package:apidash/consts.dart';
+
+class RubyNetHttpCodeGen {
+  String kTemplateStart = """require "uri"
+require "net/http"
+
+url = URI("{{url}}")
+https = Net::HTTP.new(url.host, url.port)
+{% if check == "https" %}https.use_ssl = true{% endif %}
+request = Net::HTTP::{{method}}.new(url)
+""";
+
+  String kTemplateHeader = """
+{% for key, value in headers %}
+request["{{key}}"] = "{{value}}"{% endfor %}
+""";
+
+  String kTemplateBody = """
+
+request.body = <<HEREDOC
+{{body}}
+HEREDOC
+
+""";
+  String kMultiPartBodyTemplate = r'''
+{% if type == "file" %}"{{name}}", File.open("{{value}}"){% else %}"{{name}}", "{{value}}"{% endif %}
+''';
+  String kStringRequest = """
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+{% if method != "head" %}puts "Response Body: #{response.body}"{% else %}puts "Response Body: #{response.to_hash}"{% endif %}
+
+""";
+
+  String? getCode(RequestModel requestModel) {
+    try {
+      String result = "";
+
+      var rec = getValidRequestUri(
+        requestModel.url,
+        requestModel.enabledRequestParams,
+      );
+
+      Uri? uri = rec.$1;
+
+      if (uri == null) {
+        return "";
+      }
+
+      var templateStart = jj.Template(kTemplateStart);
+      result += templateStart.render({
+        "url": uri.query.isEmpty
+            ? uri.toString().replaceFirst("?", "", uri.toString().length - 1)
+            : uri,
+        "method": requestModel.method.name.capitalize(),
+        "check": uri.scheme,
+      });
+
+      var headers = requestModel.enabledHeadersMap;
+      if (!requestModel.hasContentTypeHeader &&
+          (requestModel.hasJsonData || requestModel.hasTextData)) {
+        headers[kHeaderContentType] =
+            requestModel.requestBodyContentType.header;
+      }
+
+      if (headers.isNotEmpty) {
+        var templateHeader = jj.Template(kTemplateHeader);
+        result += templateHeader.render({
+          "headers": headers,
+        });
+      }
+
+      if (requestModel.hasTextData || requestModel.hasJsonData) {
+        var templateBody = jj.Template(kTemplateBody);
+        result += templateBody.render({
+          "body": requestModel.requestBody,
+        });
+      }
+
+      if (requestModel.hasFormData) {
+        result += "\n";
+        result += "form_data = [";
+        var templateMultiPartBody = jj.Template(kMultiPartBodyTemplate);
+        int length = requestModel.formDataMapList.length;
+
+        for (var element in requestModel.formDataMapList) {
+          result += "[";
+          result += templateMultiPartBody.render({
+            "name": element["name"],
+            "value": element["value"],
+            "type": element["type"]
+          });
+          length -= 1;
+          if (length == 0) {
+            result += "]";
+          } else {
+            result += "],";
+          }
+        }
+        result += "]\n";
+        result +=
+            "request.set_form form_data, '${ContentType.formdata.header}'";
+      }
+
+      result += jj.Template(kStringRequest)
+          .render({"method": requestModel.method.name});
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/consts.dart

@@ -272,6 +272,7 @@ const kDefaultContentType = ContentType.json;
 enum CodegenLanguage {
   curl("cURL", "bash", "curl"),
   har("HAR", "json", "har"),
+  cSharpRestSharp("C# (Rest Sharp)", "cs", "cs"),
   dartHttp("Dart (http)", "dart", "dart"),
   dartDio("Dart (dio)", "dart", "dart"),
   goHttp("Go (http)", "go", "go"),
@@ -282,6 +283,8 @@ enum CodegenLanguage {
   kotlinOkHttp("Kotlin (okhttp3)", "java", "kt"),
   pythonRequests("Python (requests)", "python", "py"),
   pythonHttpClient("Python (http.client)", "python", "py"),
+  rubyFaraday("Ruby (Faraday)", "ruby", "rb"),
+  rubyNetHttp("Ruby (Net::Http)", "Ruby", "rb"),
   rustActix("Rust (Actix Client)", "rust", "rs"),
   rustReqwest("Rust (reqwest)", "rust", "rs"),
   rustCurl("Rust (curl-rust)", "rust", "rs"),

lib/extensions/extensions.dart

@@ -0,0 +1 @@
+export 'string_extensions.dart';

lib/extensions/string_extensions.dart

@@ -0,0 +1,5 @@
+extension StringExtension on String {
+  String capitalize() {
+    return "${this[0].toUpperCase()}${substring(1).toLowerCase()}";
+  }
+}

lib/screens/home_page/editor_pane/editor_request.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:apidash/providers/collection_providers.dart';
+import 'package:apidash/providers/providers.dart';
 import 'package:apidash/consts.dart';
 import 'details_card/details_card.dart';
 import 'url_card.dart';

test/codegen/csharp_rest_sharp_codgen_test.dart

@@ -0,0 +1,982 @@
+import 'package:apidash/consts.dart';
+import 'package:apidash/screens/home_page/editor_pane/details_card/code_pane.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../request_models.dart';
+
+void main() {
+  group("Get Request Test", () {
+    test("Get 1", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("", Method.Get);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet1, "https"),
+          expectedCode);
+    });
+
+    test("Get 2", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/country/data", Method.Get);
+
+      request.AddQueryParameter("code", "US");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet2, "https"),
+          expectedCode);
+    });
+
+    test("Get 3", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/country/data", Method.Get);
+
+      request.AddQueryParameter("code", "IND");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet3, "https"),
+          expectedCode);
+    });
+
+    test("Get 4", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/humanize/social", Method.Get);
+
+      request.AddQueryParameter("num", "8700000");
+      request.AddQueryParameter("digits", "3");
+      request.AddQueryParameter("system", "SS");
+      request.AddQueryParameter("add_space", "true");
+      request.AddQueryParameter("trailing_zeros", "true");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet4, "https"),
+          expectedCode);
+    });
+
+    test("Get 5", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.github.com";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/repos/foss42/apidash", Method.Get);
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet5, "https"),
+          expectedCode);
+    });
+
+    test("Get 6", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.github.com";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/repos/foss42/apidash", Method.Get);
+
+      request.AddQueryParameter("raw", "true");
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet6, "https"),
+          expectedCode);
+    });
+
+    test("Get 7", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("", Method.Get);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet7, "https"),
+          expectedCode);
+    });
+
+    test("Get 8", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.github.com";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/repos/foss42/apidash", Method.Get);
+
+      request.AddQueryParameter("raw", "true");
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet8, "https"),
+          expectedCode);
+    });
+
+    test("Get 9", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/humanize/social", Method.Get);
+
+      request.AddQueryParameter("num", "8700000");
+      request.AddQueryParameter("add_space", "true");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet9, "https"),
+          expectedCode);
+    });
+
+    test("Get 10", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/humanize/social", Method.Get);
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet10, "https"),
+          expectedCode);
+    });
+
+    test("Get 11", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/humanize/social", Method.Get);
+
+      request.AddQueryParameter("num", "8700000");
+      request.AddQueryParameter("digits", "3");
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet11, "https"),
+          expectedCode);
+    });
+
+    test("Get 12", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/humanize/social", Method.Get);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelGet12, "https"),
+          expectedCode);
+    });
+  });
+
+  group("Head Request Test", () {
+    test("Head 1", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("", Method.Head);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelHead1, "https"),
+          expectedCode);
+    });
+
+    test("Head 2", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "http://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("", Method.Head);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelHead2, "http"),
+          expectedCode);
+    });
+  });
+
+  group("Post Request Test", () {
+    test("Post 1", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/case/lower", Method.Post);
+
+      request.AddHeader("Content-Type", "text/plain");
+
+      var textBody = "{\n\"text\": \"I LOVE Flutter\"\n}";
+      request.AddStringBody(textBody, ContentType.Plain);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost1, "https"),
+          expectedCode);
+    });
+    test("Post 2", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/case/lower", Method.Post);
+
+      request.AddHeader("Content-Type", "application/json");
+
+      var jsonBody = new {
+text = "I LOVE Flutter",
+flag = "null",
+male = "true",
+female = "false",
+no = "1.2",
+arr = "[null, true, false, null]"
+};
+      request.AddJsonBody(jsonBody);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost2, "https"),
+          expectedCode);
+    });
+    test("Post 3", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/case/lower", Method.Post);
+
+      request.AddHeader("User-Agent", "Test Agent");
+      request.AddHeader("Content-Type", "application/json");
+
+      var jsonBody = new {
+text = "I LOVE Flutter"
+};
+      request.AddJsonBody(jsonBody);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost3, "https"),
+          expectedCode);
+    });
+    test("Post 4", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/form", Method.Post);
+
+      request.AlwaysMultipartFormData = true;
+      request.AddParameter("text", "API", ParameterType.GetOrPost);
+      request.AddParameter("sep", "|", ParameterType.GetOrPost);
+      request.AddParameter("times", "3", ParameterType.GetOrPost);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost4, "https"),
+          expectedCode);
+    });
+    test("Post 5", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/form", Method.Post);
+
+      request.AddHeader("User-Agent", "Test Agent");
+
+      request.AlwaysMultipartFormData = true;
+      request.AddParameter("text", "API", ParameterType.GetOrPost);
+      request.AddParameter("sep", "|", ParameterType.GetOrPost);
+      request.AddParameter("times", "3", ParameterType.GetOrPost);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost5, "https"),
+          expectedCode);
+    });
+    test("Post 6", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/img", Method.Post);
+
+      request.AlwaysMultipartFormData = true;
+      var options = new FileParameterOptions
+      {
+          DisableFilenameEncoding = true
+      };
+      request.AddParameter("token", "xyz", ParameterType.GetOrPost);
+      request.AddFile("imfile", "/Documents/up/1.png", options: options);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost6, "https"),
+          expectedCode);
+    });
+    test("Post 7", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/img", Method.Post);
+
+      request.AlwaysMultipartFormData = true;
+      var options = new FileParameterOptions
+      {
+          DisableFilenameEncoding = true
+      };
+      request.AddParameter("token", "xyz", ParameterType.GetOrPost);
+      request.AddFile("imfile", "/Documents/up/1.png", options: options);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost7, "https"),
+          expectedCode);
+    });
+    test("Post 8", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/form", Method.Post);
+
+      request.AddQueryParameter("size", "2");
+      request.AddQueryParameter("len", "3");
+
+      request.AlwaysMultipartFormData = true;
+      request.AddParameter("text", "API", ParameterType.GetOrPost);
+      request.AddParameter("sep", "|", ParameterType.GetOrPost);
+      request.AddParameter("times", "3", ParameterType.GetOrPost);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost8, "https"),
+          expectedCode);
+    });
+    test("Post 9", () {
+      const expectedCode = r"""
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://api.apidash.dev";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/io/img", Method.Post);
+
+      request.AddQueryParameter("size", "2");
+      request.AddQueryParameter("len", "3");
+
+      request.AddHeader("User-Agent", "Test Agent");
+      request.AddHeader("Keep-Alive", "true");
+
+      request.AlwaysMultipartFormData = true;
+      var options = new FileParameterOptions
+      {
+          DisableFilenameEncoding = true
+      };
+      request.AddParameter("token", "xyz", ParameterType.GetOrPost);
+      request.AddFile("imfile", "/Documents/up/1.png", options: options);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPost9, "https"),
+          expectedCode);
+    });
+  });
+
+  group("Put Request Test", () {
+    test("Put 1", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://reqres.in";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/api/users/2", Method.Put);
+
+      request.AddHeader("Content-Type", "application/json");
+
+      var jsonBody = new {
+name = "morpheus",
+job = "zion resident"
+};
+      request.AddJsonBody(jsonBody);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPut1, "https"),
+          expectedCode);
+    });
+  });
+
+  group("Patch Request Test", () {
+    test("Patch 1", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://reqres.in";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/api/users/2", Method.Patch);
+
+      request.AddHeader("Content-Type", "application/json");
+
+      var jsonBody = new {
+name = "marfeus",
+job = "accountant"
+};
+      request.AddJsonBody(jsonBody);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group("Delete Request Test", () {
+    test("Delete 1", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://reqres.in";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/api/users/2", Method.Delete);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelDelete1, "https"),
+          expectedCode);
+    });
+    test("Delete 2", () {
+      const expectedCode = """
+using System;
+using RestSharp;
+using System.Threading.Tasks;
+
+class Program
+{
+  static async Task Main(){
+    try{
+      const String _baseUrl = "https://reqres.in";
+      var client = new RestClient(_baseUrl);
+
+      var request = new RestRequest("/api/users/2", Method.Delete);
+
+      request.AddHeader("Content-Type", "application/json");
+
+      var jsonBody = new {
+name = "marfeus",
+job = "accountant"
+};
+      request.AddJsonBody(jsonBody);
+
+      var response = await client.ExecuteAsync(request);
+      Console.WriteLine("Status Code: " + (int)response.StatusCode);
+      Console.WriteLine("Response Content: " + response.Content);
+    }
+    catch(Exception ex){
+      Console.WriteLine("Error: " + ex);
+    }
+  }
+}
+""";
+      expect(
+          codegen.getCode(
+              CodegenLanguage.cSharpRestSharp, requestModelDelete2, "https"),
+          expectedCode);
+    });
+  });
+}

test/codegen/ruby_faraday_codegen_test.dart

@@ -0,0 +1,775 @@
+import 'package:apidash/codegen/codegen.dart';
+import 'package:apidash/consts.dart';
+import 'package:test/test.dart';
+import '../request_models.dart';
+
+void main() {
+  final codeGen = Codegen();
+
+  group('GET Request', () {
+    test('GET 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet1, "https"),
+          expectedCode);
+    });
+
+    test('GET 2', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/country/data")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.params = {
+    "code" => "US",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet2, "https"),
+          expectedCode);
+    });
+
+    test('GET 3', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/country/data")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.params = {
+    "code" => "IND",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet3, "https"),
+          expectedCode);
+    });
+
+    test('GET 4', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/humanize/social")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.params = {
+    "num" => "8700000",
+    "digits" => "3",
+    "system" => "SS",
+    "add_space" => "true",
+    "trailing_zeros" => "true",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet4, "https"),
+          expectedCode);
+    });
+
+    test('GET 5', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.github.com/repos/foss42/apidash")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet5, "https"),
+          expectedCode);
+    });
+
+    test('GET 6', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.github.com/repos/foss42/apidash")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+  req.params = {
+    "raw" => "true",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet6, "https"),
+          expectedCode);
+    });
+
+    test('GET 7', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet7, "https"),
+          expectedCode);
+    });
+
+    test('GET 8', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.github.com/repos/foss42/apidash")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+  req.params = {
+    "raw" => "true",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet8, "https"),
+          expectedCode);
+    });
+
+    test('GET 9', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/humanize/social")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.params = {
+    "num" => "8700000",
+    "add_space" => "true",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet9, "https"),
+          expectedCode);
+    });
+
+    test('GET 10', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/humanize/social")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyFaraday,
+            requestModelGet10,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('GET 11', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/humanize/social")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+  req.params = {
+    "num" => "8700000",
+    "digits" => "3",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet11, "https"),
+          expectedCode);
+    });
+
+    test('GET 12', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/humanize/social")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.get(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelGet12, "https"),
+          expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.head(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelHead1, "https"),
+          expectedCode);
+    });
+
+    test('HEAD 2', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("http://api.apidash.dev")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.head(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelHead2, "http"),
+          expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/case/lower")
+
+PAYLOAD = <<HEREDOC
+{
+"text": "I LOVE Flutter"
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "Content-Type" => "text/plain",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost1, "https"),
+          expectedCode);
+    });
+
+    test('POST 2', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/case/lower")
+
+PAYLOAD = <<HEREDOC
+{
+"text": "I LOVE Flutter",
+"flag": null,
+"male": true,
+"female": false,
+"no": 1.2,
+"arr": ["null", "true", "false", null]
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "Content-Type" => "application/json",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost2, "https"),
+          expectedCode);
+    });
+
+    test('POST 3', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/case/lower")
+
+PAYLOAD = <<HEREDOC
+{
+"text": "I LOVE Flutter"
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+    "Content-Type" => "application/json",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost3, "https"),
+          expectedCode);
+    });
+
+    test('POST 4', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/form")
+
+PAYLOAD = URI.encode_www_form({
+  "text" => "API",
+  "sep" => "|",
+  "times" => "3",
+})
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyFaraday,
+            requestModelPost4,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 5', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/form")
+
+PAYLOAD = URI.encode_www_form({
+  "text" => "API",
+  "sep" => "|",
+  "times" => "3",
+})
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost5, "https"),
+          expectedCode);
+    });
+    test('POST 6', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+require 'faraday/multipart'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/img")
+
+PAYLOAD = {
+  "token" => Faraday::Multipart::ParamPart.new("xyz", "text/plain"),
+  "imfile" => Faraday::Multipart::FilePart.new("/Documents/up/1.png", "application/octet-stream"),
+}
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+  faraday.request :multipart
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost6, "https"),
+          expectedCode);
+    });
+    test('POST 7', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+require 'faraday/multipart'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/img")
+
+PAYLOAD = {
+  "token" => Faraday::Multipart::ParamPart.new("xyz", "text/plain"),
+  "imfile" => Faraday::Multipart::FilePart.new("/Documents/up/1.png", "application/octet-stream"),
+}
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+  faraday.request :multipart
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost7, "https"),
+          expectedCode);
+    });
+    test('POST 8', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/form")
+
+PAYLOAD = URI.encode_www_form({
+  "text" => "API",
+  "sep" => "|",
+  "times" => "3",
+})
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.params = {
+    "size" => "2",
+    "len" => "3",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost8, "https"),
+          expectedCode);
+    });
+    test('POST 9', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+require 'faraday/multipart'
+
+REQUEST_URL = URI("https://api.apidash.dev/io/img")
+
+PAYLOAD = {
+  "token" => Faraday::Multipart::ParamPart.new("xyz", "text/plain"),
+  "imfile" => Faraday::Multipart::FilePart.new("/Documents/up/1.png", "application/octet-stream"),
+}
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+  faraday.request :multipart
+end
+
+response = conn.post(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "User-Agent" => "Test Agent",
+    "Keep-Alive" => "true",
+  }
+  req.params = {
+    "size" => "2",
+    "len" => "3",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPost9, "https"),
+          expectedCode);
+    });
+  });
+
+  group('PUT Request', () {
+    test('PUT 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://reqres.in/api/users/2")
+
+PAYLOAD = <<HEREDOC
+{
+"name": "morpheus",
+"job": "zion resident"
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.put(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "Content-Type" => "application/json",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPut1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('PATCH Request', () {
+    test('PATCH 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://reqres.in/api/users/2")
+
+PAYLOAD = <<HEREDOC
+{
+"name": "marfeus",
+"job": "accountant"
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.patch(REQUEST_URL, PAYLOAD) do |req|
+  req.headers = {
+    "Content-Type" => "application/json",
+  }
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('DELETE Request', () {
+    test('DELETE 1', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://reqres.in/api/users/2")
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.delete(REQUEST_URL) do |req|
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelDelete1, "https"),
+          expectedCode);
+    });
+
+    test('DELETE 2', () {
+      const expectedCode = r"""require 'uri'
+require 'faraday'
+
+REQUEST_URL = URI("https://reqres.in/api/users/2")
+
+PAYLOAD = <<HEREDOC
+{
+"name": "marfeus",
+"job": "accountant"
+}
+HEREDOC
+
+conn = Faraday.new do |faraday|
+  faraday.adapter Faraday.default_adapter
+end
+
+response = conn.delete(REQUEST_URL) do |req|
+  req.headers = {
+    "Content-Type" => "application/json",
+  }
+  req.body = PAYLOAD
+end
+
+puts "Status Code: #{response.status}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyFaraday, requestModelDelete2, "https"),
+          expectedCode);
+    });
+  });
+}

test/codegen/ruby_net_http_codegen_test.dart

@@ -0,0 +1,620 @@
+import 'package:apidash/codegen/codegen.dart';
+import 'package:apidash/consts.dart';
+import 'package:test/test.dart';
+import '../request_models.dart';
+
+void main() {
+  final codeGen = Codegen();
+
+  group('GET Request', () {
+    test('GET 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet1, "https"),
+          expectedCode);
+    });
+
+    test('GET 2', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/country/data?code=US")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet2, "https"),
+          expectedCode);
+    });
+
+    test('GET 3', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/country/data?code=IND")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet3, "https"),
+          expectedCode);
+    });
+
+    test('GET 4', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/humanize/social?num=8700000&digits=3&system=SS&add_space=true&trailing_zeros=true")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet4, "https"),
+          expectedCode);
+    });
+
+    test('GET 5', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.github.com/repos/foss42/apidash")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+request["User-Agent"] = "Test Agent"
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet5, "https"),
+          expectedCode);
+    });
+
+    test('GET 6', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.github.com/repos/foss42/apidash?raw=true")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+request["User-Agent"] = "Test Agent"
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet6, "https"),
+          expectedCode);
+    });
+
+    test('GET 7', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet7, "https"),
+          expectedCode);
+    });
+
+    test('GET 8', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.github.com/repos/foss42/apidash?raw=true")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+request["User-Agent"] = "Test Agent"
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet8, "https"),
+          expectedCode);
+    });
+
+    test('GET 9', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/humanize/social?num=8700000&add_space=true")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet9, "https"),
+          expectedCode);
+    });
+
+    test('GET 10', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/humanize/social")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+request["User-Agent"] = "Test Agent"
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelGet10,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('GET 11', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/humanize/social?num=8700000&digits=3")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+request["User-Agent"] = "Test Agent"
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet11, "https"),
+          expectedCode);
+    });
+
+    test('GET 12', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/humanize/social")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Get.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelGet12, "https"),
+          expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Head.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.to_hash}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelHead1, "https"),
+          expectedCode);
+    });
+
+    test('HEAD 2', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("http://api.apidash.dev")
+https = Net::HTTP.new(url.host, url.port)
+
+request = Net::HTTP::Head.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.to_hash}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelHead2, "http"),
+          expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/case/lower")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+request["Content-Type"] = "text/plain"
+request.body = <<HEREDOC
+{
+"text": "I LOVE Flutter"
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelPost1, "https"),
+          expectedCode);
+    });
+
+    test('POST 2', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/case/lower")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+request["Content-Type"] = "application/json"
+request.body = <<HEREDOC
+{
+"text": "I LOVE Flutter",
+"flag": null,
+"male": true,
+"female": false,
+"no": 1.2,
+"arr": ["null", "true", "false", null]
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelPost2, "https"),
+          expectedCode);
+    });
+
+    test('POST 3', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/case/lower")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+request["User-Agent"] = "Test Agent"
+request["Content-Type"] = "application/json"
+request.body = <<HEREDOC
+{
+"text": "I LOVE Flutter"
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelPost3, "https"),
+          expectedCode);
+    });
+    test('POST 4', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/form")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost4,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('POST 5', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/form")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+request["User-Agent"] = "Test Agent"
+form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost5,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 6', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/img")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost6,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 7', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/img")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost7,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 8', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/form?size=2&len=3")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost8,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 9', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://api.apidash.dev/io/img?size=2&len=3")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Post.new(url)
+request["User-Agent"] = "Test Agent"
+request["Keep-Alive"] = "true"
+form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+request.set_form form_data, 'multipart/form-data'
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost9,
+            "https",
+          ),
+          expectedCode);
+    });
+  });
+
+  group('PUT Request', () {
+    test('PUT 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://reqres.in/api/users/2")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Put.new(url)
+request["Content-Type"] = "application/json"
+request.body = <<HEREDOC
+{
+"name": "morpheus",
+"job": "zion resident"
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelPut1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('PATCH Request', () {
+    test('PATCH 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://reqres.in/api/users/2")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Patch.new(url)
+request["Content-Type"] = "application/json"
+request.body = <<HEREDOC
+{
+"name": "marfeus",
+"job": "accountant"
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('DELETE Request', () {
+    test('DELETE 1', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://reqres.in/api/users/2")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Delete.new(url)
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelDelete1, "https"),
+          expectedCode);
+    });
+
+    test('DELETE 2', () {
+      const expectedCode = r"""require "uri"
+require "net/http"
+
+url = URI("https://reqres.in/api/users/2")
+https = Net::HTTP.new(url.host, url.port)
+https.use_ssl = true
+request = Net::HTTP::Delete.new(url)
+request["Content-Type"] = "application/json"
+request.body = <<HEREDOC
+{
+"name": "marfeus",
+"job": "accountant"
+}
+HEREDOC
+
+response = https.request(request)
+
+puts "Response Code: #{response.code}"
+puts "Response Body: #{response.body}"
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelDelete2, "https"),
+          expectedCode);
+    });
+  });
+}