5938580990

Committed 22 Aug 2023 12:11PM UTC coverage: 53.333%. First build

Build # 5938580990

Build Type

Pull #4

github

Committed by

web-flow

Commit Message

Merge c9b890bd3 into af982d347

Pull Request Pull Request #4: Update go version

Run Details

22 of 22 new or added lines in 2 files covered. (100.0%)

48 of 90 relevant lines covered (53.33%)

1.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.76

/request.go

package main

import (
        "flag"
        "fmt"
        "net/http"
        "net/url"
        "os"
        "strings"

        "github.com/armosec/utils-go/httputils"
)

type FlagParser struct {
        fullURL      url.URL
        pathToBody   string
        headers      string
        method       string
        pathToOutput string
}

func NewFlagParser() *FlagParser {
        return &FlagParser{
                fullURL: url.URL{},
        }
}
func (f *FlagParser) parser() {

        flag.StringVar(&f.method, "method", "", "http method (GET/POST/DELETE)")
        flag.StringVar(&f.fullURL.Scheme, "scheme", "http", "request scheme")
        flag.StringVar(&f.fullURL.Host, "host", "", "host")
        flag.StringVar(&f.fullURL.Path, "path", "", "path")

        flag.StringVar(&f.pathToBody, "path-body", "", "path to body")
        flag.StringVar(&f.headers, "headers", "", "http headers")
        flag.StringVar(&f.pathToOutput, "path-output", "", "path to output file")

        flag.Parse()
}

func (f *FlagParser) validate() error {
        if f.fullURL.Host == "" {
                return fmt.Errorf("missing host")
        }
        if f.method == "" {
                return fmt.Errorf("missing method")
        }
        return nil
}

func loadHeaders(f *FlagParser) (map[string]string, error) {
        headers := map[string]string{}
        if f.headers != "" {
                splitteedHeaders := strings.Split(f.headers, ";")
                for i := range splitteedHeaders {
                        header := strings.Split(splitteedHeaders[i], ":")
                        if len(header) == 2 {
                                headers[header[0]] = strings.TrimLeft(header[1], " ")
                        }
                }
                return headers, nil
        }
        return headers, nil
}

func loadBody(f *FlagParser) ([]byte, error) {
        if f.pathToBody != "" {
                fmt.Printf("loading body from: %s\n", f.pathToBody)
                return os.ReadFile(f.pathToBody)
        }
        return []byte{}, nil
}

// Request run a http request
func Request(f *FlagParser) (string, error) {
        var resp *http.Response
        var err error

        headers, e := loadHeaders(f)
        if e != nil {
                return "", e
        }
        body, e := loadBody(f)
        if e != nil {
                return "", e
        }

        fmt.Printf("method: %s, url: %s, headers: %v, body: %s\n", f.method, f.fullURL.String(), headers, body)

        switch strings.ToUpper(f.method) {
        case http.MethodPost:
                resp, err = httputils.HttpPost(http.DefaultClient, f.fullURL.String(), headers, body)
        case http.MethodGet:
                resp, err = httputils.HttpGet(http.DefaultClient, f.fullURL.String(), headers)
        case http.MethodDelete:
                resp, err = httputils.HttpDelete(http.DefaultClient, f.fullURL.String(), headers)
        default:
                return "", fmt.Errorf("method %s not supported", f.method)
        }

        if err != nil {
                return "", err
        }

        strResp, e := httputils.HttpRespToString(resp)
        if e != nil {
                return "", fmt.Errorf("failed to parse http response to string, reason: %s", e.Error())
        }

        if f.pathToOutput != "" {
                if err := os.WriteFile(f.pathToOutput, []byte(strResp), 0644); err != nil {
                        return "", fmt.Errorf("error writing response to file: %s", err.Error())
                }
                fmt.Printf("response was written to file: %s\n", f.pathToOutput)

        }
        return strResp, nil
}

1	package main
2
3	import (
4	"flag"
5	"fmt"
6	"net/http"
7	"net/url"
8	"os"
9	"strings"
10
11	"github.com/armosec/utils-go/httputils"
12	)
13
14	type FlagParser struct {
15	fullURL url.URL
16	pathToBody string
17	headers string
18	method string
19	pathToOutput string
20	}
21
22	func NewFlagParser() *FlagParser {	3✔
23	return &FlagParser{	3✔
24	fullURL: url.URL{},	3✔
25	}	3✔
26	}	3✔
27	func (f *FlagParser) parser() {	×
28		×
29	flag.StringVar(&f.method, "method", "", "http method (GET/POST/DELETE)")	×
30	flag.StringVar(&f.fullURL.Scheme, "scheme", "http", "request scheme")	×
31	flag.StringVar(&f.fullURL.Host, "host", "", "host")	×
32	flag.StringVar(&f.fullURL.Path, "path", "", "path")	×
33		×
34	flag.StringVar(&f.pathToBody, "path-body", "", "path to body")	×
35	flag.StringVar(&f.headers, "headers", "", "http headers")	×
36	flag.StringVar(&f.pathToOutput, "path-output", "", "path to output file")	×
37		×
38	flag.Parse()	×
39	}	×
40
41	func (f *FlagParser) validate() error {	2✔
42	if f.fullURL.Host == "" {	3✔
43	return fmt.Errorf("missing host")	1✔
44	}	1✔
45	if f.method == "" {	1✔
46	return fmt.Errorf("missing method")	×
47	}	×
48	return nil	1✔
49	}
50
51	func loadHeaders(f *FlagParser) (map[string]string, error) {	5✔
52	headers := map[string]string{}	5✔
53	if f.headers != "" {	10✔
54	splitteedHeaders := strings.Split(f.headers, ";")	5✔
55	for i := range splitteedHeaders {	14✔
56	header := strings.Split(splitteedHeaders[i], ":")	9✔
57	if len(header) == 2 {	18✔
58	headers[header[0]] = strings.TrimLeft(header[1], " ")	9✔
59	}	9✔
60	}
61	return headers, nil	5✔
62	}
63	return headers, nil	×
64	}
65
66	func loadBody(f *FlagParser) ([]byte, error) {	3✔
67	if f.pathToBody != "" {	3✔
68	fmt.Printf("loading body from: %s\n", f.pathToBody)	×
69	return os.ReadFile(f.pathToBody)	×
70	}	×
71	return []byte{}, nil	3✔
72	}
73
74	// Request run a http request
75	func Request(f *FlagParser) (string, error) {	3✔
76	var resp *http.Response	3✔
77	var err error	3✔
78		3✔
79	headers, e := loadHeaders(f)	3✔
80	if e != nil {	3✔
81	return "", e	×
82	}	×
83	body, e := loadBody(f)	3✔
84	if e != nil {	3✔
85	return "", e	×
86	}	×
87
88	fmt.Printf("method: %s, url: %s, headers: %v, body: %s\n", f.method, f.fullURL.String(), headers, body)	3✔
89		3✔
90	switch strings.ToUpper(f.method) {	3✔
91	case http.MethodPost:	1✔
92	resp, err = httputils.HttpPost(http.DefaultClient, f.fullURL.String(), headers, body)	1✔
93	case http.MethodGet:	1✔
94	resp, err = httputils.HttpGet(http.DefaultClient, f.fullURL.String(), headers)	1✔
95	case http.MethodDelete:	1✔
96	resp, err = httputils.HttpDelete(http.DefaultClient, f.fullURL.String(), headers)	1✔
97	default:	×
98	return "", fmt.Errorf("method %s not supported", f.method)	×
99	}
100
101	if err != nil {	3✔
102	return "", err	×
103	}	×
104
105	strResp, e := httputils.HttpRespToString(resp)	3✔
106	if e != nil {	3✔
107	return "", fmt.Errorf("failed to parse http response to string, reason: %s", e.Error())	×
108	}	×
109
110	if f.pathToOutput != "" {	4✔
111	if err := os.WriteFile(f.pathToOutput, []byte(strResp), 0644); err != nil {	1✔
112	return "", fmt.Errorf("error writing response to file: %s", err.Error())	×
113	}	×
114	fmt.Printf("response was written to file: %s\n", f.pathToOutput)	1✔
115
116	}
117	return strResp, nil	3✔
118	}

kubescape / http-request / 5938580990

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous