diff --git a/lib/codegen/rust/hyper.dart b/lib/codegen/rust/hyper.dart
index 15794119..947249dc 100644
--- a/lib/codegen/rust/hyper.dart
+++ b/lib/codegen/rust/hyper.dart
@@ -1,45 +1,38 @@
 import 'dart:core';
 import 'package:jinja/jinja.dart' as jj;
 import 'package:apidash/consts.dart';
-import 'package:apidash/utils/utils.dart'
-    show  getValidRequestUri;
+import 'package:apidash/utils/utils.dart' show getValidRequestUri;
 import 'package:apidash/models/models.dart';
 
-
 class RustHyperCodeGen {
   final String kTemplateStart = """
-{% if hasForm %}extern crate hyper_multipart_rfc7578 as hyper_multipart;{% endif %}
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-{% if hasForm %}use hyper_multipart::client::multipart;{% endif %}
-{% if hasJsonBody %}use serde_json::json;{% endif %}
-use tokio;
+{% if hasForm %}extern crate hyper_multipart_rfc7578 as hyper_multipart;
+{% endif %}use hyper::{Body, Client, Request, Uri};
+{% if isHttps %}use hyper_tls::HttpsConnector;
+{% else %}use hyper::client::HttpConnector;
+{% endif %}{% if hasForm %}use hyper_multipart::client::multipart;
+{% endif %}{% if hasJsonBody %}use serde_json::json;
+{% endif %}use tokio;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
+    let http{% if isHttps %}s{% endif %} = Http{% if isHttps %}s{% endif %}Connector::new();
+    let client = Client::builder().build::<_, hyper::Body>(http{% if isHttps %}s{% endif %});
     let url = "{{ url }}".parse::<Uri>().unwrap();
 
 """;
 
-  
-
-
   final String kTemplateMethod = """
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("{{ method }}")
               .uri(url)
 """;
   final String kTemplateMethodNoHeadersButForm = """
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("{{ method }}")
               .uri(url);
 """;
 
-
-
   final String kTemplateHeaders = """
         {% for key, val in headers %}
               .header("{{ key }}", "{{ val }}")
@@ -51,7 +44,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         {% endfor %}
 """;
 
-
   final String kTemplateBody = """
         
               .body(Body::from(r#"{{ body }}"#))?;\n
@@ -67,11 +59,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
               .body(Body::empty())?;\n
 """;
 
-
-
-
-
-final String kTemplateFormData = """
+  final String kTemplateFormData = """
     
     let mut form = multipart::Form::default();
     {%- for field in fields_list %}
@@ -82,12 +70,11 @@ final String kTemplateFormData = """
         {%- endif %}
     {%- endfor %}
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
   """;
 
-
-   final String kTemplateEndForm = """
+  final String kTemplateEndForm = """
   let res = client.request(req).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
@@ -100,7 +87,7 @@ final String kTemplateFormData = """
 """;
 
   final String kTemplateRequestEnd = """
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -110,83 +97,76 @@ final String kTemplateFormData = """
 
 """;
 
-
-  final String kTemplateEnd = """ 
+  final String kTemplateEnd = """
     Ok(())
 }
 
 """;
 
-
-  
-
-
-
   String? getCode(HttpRequestModel requestModel) {
     try {
-      
       String result = "";
-      
+
       String url = requestModel.url;
       var rec = getValidRequestUri(url, requestModel.enabledParams);
       Uri? uri = rec.$1;
 
       if (uri != null) {
-
         var headers = requestModel.enabledHeadersMap;
         result += jj.Template(kTemplateStart).render({
           "url": uri,
-          'hasJsonBody': requestModel.bodyContentType == ContentType.json,
+          "isHttps": uri.scheme == "https" ? true : false,
+          'hasJsonBody': requestModel.hasJsonData,
           'hasForm': requestModel.hasFormData,
         });
-        
-        if(requestModel.hasFormData && headers.isEmpty){
-          result += jj.Template(kTemplateMethodNoHeadersButForm).render({
-          "method": requestModel.method.name.toUpperCase(),
-        });
-        }else{
-          result += jj.Template(kTemplateMethod).render({
-          "method": requestModel.method.name.toUpperCase(),
-        });
 
+        if (requestModel.hasFormData && headers.isEmpty) {
+          result += jj.Template(kTemplateMethodNoHeadersButForm).render({
+            "method": requestModel.method.name.toUpperCase(),
+          });
+        } else {
+          result += jj.Template(kTemplateMethod).render({
+            "method": requestModel.method.name.toUpperCase(),
+          });
         }
-        
 
         // Add headers if available
-        
+
         if (headers.isNotEmpty) {
-          if(requestModel.hasFormData){
-            result += jj.Template(kTemplateHeadersFormData).render({"headers": headers});
-          }else{
-            result += jj.Template(kTemplateHeaders).render({"headers": headers});
+          if (requestModel.hasFormData) {
+            result += jj.Template(kTemplateHeadersFormData)
+                .render({"headers": headers});
+          } else {
+            result +=
+                jj.Template(kTemplateHeaders).render({"headers": headers});
           }
-          
         }
 
         // Handle body (JSON or raw)
         var requestBody = requestModel.body;
         if (requestModel.hasFormData) {
-          
           result += jj.Template(kTemplateFormData).render({
             "fields_list": requestModel.formDataMapList,
           });
-        }else if (requestBody == "" || requestBody == null|| requestModel.method ==HTTPVerb.get || requestModel.method == HTTPVerb.head) {
+        } else if (requestBody == "" ||
+            requestBody == null ||
+            requestModel.method == HTTPVerb.get ||
+            requestModel.method == HTTPVerb.head) {
           result += kTemplateEmptyBody;
-        }else if(requestModel.hasJsonData){
-          result += jj.Template(kTemplateJsonBody).render({"body": requestBody});
-
-        }else if(requestModel.hasTextData){
+        } else if (requestModel.hasJsonData) {
+          result +=
+              jj.Template(kTemplateJsonBody).render({"body": requestBody});
+        } else if (requestModel.hasTextData) {
           result += jj.Template(kTemplateBody).render({"body": requestBody});
         }
         // End request
-        
-        if(requestModel.hasFormData && requestModel.method!=HTTPVerb.get){
-          result+=kTemplateEndForm;
-        }else{
-          result+=kTemplateRequestEnd;
 
+        if (requestModel.hasFormData && requestModel.method != HTTPVerb.get) {
+          result += kTemplateEndForm;
+        } else {
+          result += kTemplateRequestEnd;
         }
-        result+=kTemplateEnd;
+        result += kTemplateEnd;
       }
 
       return result;
diff --git a/test/codegen/rust_hyper_codegen_test.dart b/test/codegen/rust_hyper_codegen_test.dart
index e1ced7f1..6c70173e 100644
--- a/test/codegen/rust_hyper_codegen_test.dart
+++ b/test/codegen/rust_hyper_codegen_test.dart
@@ -3,579 +3,26 @@ import 'package:apidash/consts.dart';
 import 'package:test/test.dart';
 import '../models/request_models.dart';
 
-
-void main(){
-
+void main() {
   final codeGen = Codegen();
-  group('GET Request',(){
-    test('GET1', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet1, "https"),
-          expectedCode);
-    });
-    test('GET2', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/country/data?code=US".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet2, "https"),
-          expectedCode);
-    });
-
-    test('GET3', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/country/data?code=IND".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet3, "https"),
-          expectedCode);
-    });
-
-    test('GET4', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/humanize/social?num=8700000&digits=3&system=SS&add_space=true&trailing_zeros=true".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet4, "https"),
-          expectedCode);
-    });
-
-
-     test('GET5', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.github.com/repos/foss42/apidash".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)        
-              .header("User-Agent", "Test Agent")
-        
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet5, "https"),
-          expectedCode);
-    });
-
-
-
-     test('GET6', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.github.com/repos/foss42/apidash?raw=true".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)        
-              .header("User-Agent", "Test Agent")
-        
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet6, "https"),
-          expectedCode);
-    });
-
-
-
-
-     test('GET7', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet7, "https"),
-          expectedCode);
-    });
-
-
-
-
-     test('GET8', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.github.com/repos/foss42/apidash?raw=true".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)        
-              .header("User-Agent", "Test Agent")
-        
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet8, "https"),
-          expectedCode);
-    });
-    test('GET9', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/humanize/social?num=8700000&add_space=true".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet9, "https"),
-          expectedCode);
-    });
-
-    test('GET10', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/humanize/social".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)        
-              .header("User-Agent", "Test Agent")
-        
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet10, "https"),
-          expectedCode);
-    });
-
-
-    
-    test('GET11', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/humanize/social?num=8700000&digits=3".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)        
-              .header("User-Agent", "Test Agent")
-        
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet11, "https"),
-          expectedCode);
-    });
-
-
-    test('GET12', (){
-      const expectedCode =r"""
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/humanize/social".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("GET")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-  expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet12, "https"),
-          expectedCode);
-    });
-
-  });
-
-
-  group('HEAD Request', (){
-    test('HEAD1',(){
-      const expectedCode = """
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("HEAD")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-    expect(codeGen.getCode(CodegenLanguage.rustHyper, requestModelHead1, "https"),
-          expectedCode);
-    });
-
-    test('HEAD2',(){
-      const expectedCode = """
-
-use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
-use hyper_tls::HttpsConnector;
-
-use serde_json::json;
-use tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let https = HttpsConnector::new();
-    let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("HEAD")
-              .uri(url)
-              .body(Body::empty())?;
-
-    let res = client.request(reqBuilder).await?;
-    let status = res.status();
-    let body_bytes = hyper::body::to_bytes(res).await?;
-    let body = String::from_utf8(body_bytes.to_vec())?;
-
-    println!("Response Status: {}", status);
-    println!("Response: {:?}", body);
-
-    Ok(())
-}
-
-""";
-    expect(codeGen.getCode(CodegenLanguage.rustHyper, requestModelHead2, "https"),
-          expectedCode);
-    });
-
-
-
-  });
-
-
-    group('POST Request', () {
-    test('POST1', () {
+  group('GET Request', () {
+    test('GET1', () {
       const expectedCode = r"""
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
-
 use tokio;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
-    let url = "https://api.apidash.dev/case/lower".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
-              .method("POST")
-              .uri(url)        
-              .body(Body::from(r#"{
-"text": "I LOVE Flutter"
-}"#))?;
-    let res = client.request(reqBuilder).await?;
+    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -588,16 +35,493 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost1, "https"),
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet1, "https"),
+          expectedCode);
+    });
+    test('GET2', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/country/data?code=US".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet2, "https"),
+          expectedCode);
+    });
+
+    test('GET3', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/country/data?code=IND".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet3, "https"),
+          expectedCode);
+    });
+
+    test('GET4', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/humanize/social?num=8700000&digits=3&system=SS&add_space=true&trailing_zeros=true".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet4, "https"),
+          expectedCode);
+    });
+
+    test('GET5', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.github.com/repos/foss42/apidash".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)        
+              .header("User-Agent", "Test Agent")
+        
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet5, "https"),
+          expectedCode);
+    });
+
+    test('GET6', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.github.com/repos/foss42/apidash?raw=true".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)        
+              .header("User-Agent", "Test Agent")
+        
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet6, "https"),
+          expectedCode);
+    });
+
+    test('GET7', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet7, "https"),
+          expectedCode);
+    });
+
+    test('GET8', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.github.com/repos/foss42/apidash?raw=true".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)        
+              .header("User-Agent", "Test Agent")
+        
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet8, "https"),
+          expectedCode);
+    });
+    test('GET9', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/humanize/social?num=8700000&add_space=true".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelGet9, "https"),
+          expectedCode);
+    });
+
+    test('GET10', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/humanize/social".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)        
+              .header("User-Agent", "Test Agent")
+        
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelGet10, "https"),
+          expectedCode);
+    });
+
+    test('GET11', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/humanize/social?num=8700000&digits=3".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)        
+              .header("User-Agent", "Test Agent")
+        
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelGet11, "https"),
+          expectedCode);
+    });
+
+    test('GET12', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/humanize/social".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("GET")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelGet12, "https"),
+          expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD1', () {
+      const expectedCode = """
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("HEAD")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelHead1, "https"),
+          expectedCode);
+    });
+
+    test('HEAD2', () {
+      const expectedCode = """
+use hyper::{Body, Client, Request, Uri};
+use hyper::client::HttpConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let http = HttpConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(http);
+    let url = "http://api.apidash.dev".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("HEAD")
+              .uri(url)
+              .body(Body::empty())?;
+
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelHead2, "http"),
+          expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST1', () {
+      const expectedCode = r"""
+use hyper::{Body, Client, Request, Uri};
+use hyper_tls::HttpsConnector;
+use tokio;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let url = "https://api.apidash.dev/case/lower".parse::<Uri>().unwrap();
+    let req_builder = Request::builder()
+              .method("POST")
+              .uri(url)        
+              .body(Body::from(r#"{
+"text": "I LOVE Flutter"
+}"#))?;
+    let res = client.request(req_builder).await?;
+    let status = res.status();
+    let body_bytes = hyper::body::to_bytes(res).await?;
+    let body = String::from_utf8(body_bytes.to_vec())?;
+
+    println!("Response Status: {}", status);
+    println!("Response: {:?}", body);
+
+    Ok(())
+}
+
+""";
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost1, "https"),
           expectedCode);
     });
     test('POST2', () {
       const expectedCode = r"""
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
 use serde_json::json;
 use tokio;
 
@@ -606,7 +530,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/case/lower".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url)        
               .body(Body::from(json!({
@@ -617,7 +541,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 "no": 1.2,
 "arr": ["null", "true", "false", null]
 }).to_string()))?;
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -630,16 +554,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost2, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost2, "https"),
           expectedCode);
     });
     test('POST3', () {
       const expectedCode = r"""
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
 use serde_json::json;
 use tokio;
 
@@ -648,7 +570,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/case/lower".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url)        
               .header("User-Agent", "Test Agent")
@@ -656,7 +578,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
               .body(Body::from(json!({
 "text": "I LOVE Flutter"
 }).to_string()))?;
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -669,17 +591,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost3, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost3, "https"),
           expectedCode);
     });
     test('POST4', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -687,7 +608,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/form".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url);    
     let mut form = multipart::Form::default();
@@ -695,7 +616,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     form.add_text("sep", "|");
     form.add_text("times", "3");
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -711,17 +632,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost4, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost4, "https"),
           expectedCode);
     });
     test('POST5', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -729,7 +649,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/form".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url)        
               .header("User-Agent", "Test Agent");
@@ -739,7 +659,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     form.add_text("sep", "|");
     form.add_text("times", "3");
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -755,17 +675,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost5, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost5, "https"),
           expectedCode);
     });
     test('POST6', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -773,14 +692,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/img".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url);    
     let mut form = multipart::Form::default();
     form.add_text("token", "xyz");
     form.add_file("imfile", r"/Documents/up/1.png").unwrap();
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -796,17 +715,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost6, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost6, "https"),
           expectedCode);
     });
     test('POST7', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -814,14 +732,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/img".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url);    
     let mut form = multipart::Form::default();
     form.add_text("token", "xyz");
     form.add_file("imfile", r"/Documents/up/1.png").unwrap();
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -837,17 +755,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost7, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost7, "https"),
           expectedCode);
     });
     test('POST8', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -855,7 +772,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/form?size=2&len=3".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url);    
     let mut form = multipart::Form::default();
@@ -863,7 +780,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     form.add_text("sep", "|");
     form.add_text("times", "3");
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -879,17 +796,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost8, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost8, "https"),
           expectedCode);
     });
     test('POST9', () {
       const expectedCode = r"""
 extern crate hyper_multipart_rfc7578 as hyper_multipart;
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
 use hyper_multipart::client::multipart;
-
 use tokio;
 
 #[tokio::main]
@@ -897,7 +813,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://api.apidash.dev/io/img?size=2&len=3".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("POST")
               .uri(url)        
               .header("User-Agent", "Test Agent")
@@ -908,7 +824,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     form.add_text("token", "xyz");
     form.add_file("imfile", r"/Documents/up/1.png").unwrap();
 
-    let req = form.set_body_convert::<Body, multipart::Body>(reqBuilder).unwrap();
+    let req = form.set_body_convert::<Body, multipart::Body>(req_builder).unwrap();
     
     let res = client.request(req).await?;
     let status = res.status();
@@ -924,20 +840,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 """;
       expect(
-          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPost9, "https"),
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPost9, "https"),
           expectedCode);
     });
   });
-  
 
-  group('PUT Request', (){
-    test('PUT1',(){
+  group('PUT Request', () {
+    test('PUT1', () {
       const expectedCode = """
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
 use serde_json::json;
 use tokio;
 
@@ -946,14 +859,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://reqres.in/api/users/2".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("PUT")
               .uri(url)        
               .body(Body::from(json!({
 "name": "morpheus",
 "job": "zion resident"
 }).to_string()))?;
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -965,22 +878,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 """;
-    expect(codeGen.getCode(CodegenLanguage.rustHyper, requestModelPut1, "https"),
+      expect(
+          codeGen.getCode(CodegenLanguage.rustHyper, requestModelPut1, "https"),
           expectedCode);
-    });     
-   
-  
-
+    });
   });
 
-  group('PATCH Request', (){
-    test('PATCH1',(){
+  group('PATCH Request', () {
+    test('PATCH1', () {
       const expectedCode = """
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
 use serde_json::json;
 use tokio;
 
@@ -989,14 +897,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://reqres.in/api/users/2".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("PATCH")
               .uri(url)        
               .body(Body::from(json!({
 "name": "marfeus",
 "job": "accountant"
 }).to_string()))?;
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -1008,7 +916,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 """;
-  expect(codeGen.getCode(CodegenLanguage.rustHyper, requestModelPatch1, "https"),
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rustHyper, requestModelPatch1, "https"),
           expectedCode);
     });
   });
@@ -1016,12 +926,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
   group('DELETE Request', () {
     test('DELETE1', () {
       const expectedCode = r"""
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
-use serde_json::json;
 use tokio;
 
 #[tokio::main]
@@ -1029,12 +935,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://reqres.in/api/users/2".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("DELETE")
               .uri(url)
               .body(Body::empty())?;
 
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -1053,11 +959,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     });
     test('DELETE2', () {
       const expectedCode = r"""
-
 use hyper::{Body, Client, Request, Uri};
-use hyper::client::HttpConnector;
 use hyper_tls::HttpsConnector;
-
 use serde_json::json;
 use tokio;
 
@@ -1066,14 +969,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let https = HttpsConnector::new();
     let client = Client::builder().build::<_, hyper::Body>(https);
     let url = "https://reqres.in/api/users/2".parse::<Uri>().unwrap();
-    let reqBuilder = Request::builder()
+    let req_builder = Request::builder()
               .method("DELETE")
               .uri(url)        
               .body(Body::from(json!({
 "name": "marfeus",
 "job": "accountant"
 }).to_string()))?;
-    let res = client.request(reqBuilder).await?;
+    let res = client.request(req_builder).await?;
     let status = res.status();
     let body_bytes = hyper::body::to_bytes(res).await?;
     let body = String::from_utf8(body_bytes.to_vec())?;
@@ -1091,7 +994,4 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
           expectedCode);
     });
   });
-
-
-  
-}
\ No newline at end of file
+}