Merge branch 'main' of https://github.com/foss42/apidash

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`    |         |

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';
@@ -85,6 +86,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/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"),

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()}";
+  }
+}

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);
+    });
+  });
+}