How to use Post method of parallel_support_test Package

...62					endReport3 = types.Report{StartTime: t.Add(-time.Second), EndTime: t.Add(2 * time.Second), SuiteSucceeded: false, SpecReports: types.SpecReports{specReportC}}63				})64				Context("before all procs have reported SuiteWillBegin", func() {65					BeforeEach(func() {66						Ω(client.PostSuiteWillBegin(beginReport)).Should(Succeed())67						Ω(client.PostDidRun(specReportA)).Should(Succeed())68						Ω(client.PostSuiteWillBegin(beginReport)).Should(Succeed())69						Ω(client.PostDidRun(specReportB)).Should(Succeed())70					})71					It("should not forward anything to the attached reporter", func() {72						Ω(reporter.Begin).Should(BeZero())73						Ω(reporter.Will).Should(BeEmpty())74						Ω(reporter.Did).Should(BeEmpty())75					})76					Context("when the final proc reports SuiteWillBegin", func() {77						BeforeEach(func() {78							Ω(client.PostSuiteWillBegin(thirdBeginReport)).Should(Succeed())79						})80						It("forwards to SuiteWillBegin and catches up on any received summaries", func() {81							Ω(reporter.Begin).Should(Equal(thirdBeginReport))82							Ω(reporter.Will.Names()).Should(ConsistOf("A", "B"))83							Ω(reporter.Did.Names()).Should(ConsistOf("A", "B"))84						})85						Context("any subsequent summaries", func() {86							BeforeEach(func() {87								Ω(client.PostDidRun(specReportC)).Should(Succeed())88							})89							It("are forwarded immediately", func() {90								Ω(reporter.Will.Names()).Should(ConsistOf("A", "B", "C"))91								Ω(reporter.Did.Names()).Should(ConsistOf("A", "B", "C"))92							})93						})94						Context("when SuiteDidEnd start arriving", func() {95							BeforeEach(func() {96								Ω(client.PostSuiteDidEnd(endReport1)).Should(Succeed())97								Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())98							})99							It("does not forward them yet...", func() {100								Ω(reporter.End).Should(BeZero())101							})102							It("doesn't signal it's done", func() {103								Ω(server.GetSuiteDone()).ShouldNot(BeClosed())104							})105							Context("when the final SuiteDidEnd arrive", func() {106								BeforeEach(func() {107									Ω(client.PostSuiteDidEnd(endReport3)).Should(Succeed())108								})109								It("forwards the aggregation of all received end summaries", func() {110									Ω(reporter.End.StartTime.Unix()).Should(BeNumerically("~", t.Add(-2*time.Second).Unix()))111									Ω(reporter.End.EndTime.Unix()).Should(BeNumerically("~", t.Add(2*time.Second).Unix()))112									Ω(reporter.End.RunTime).Should(BeNumerically("~", 4*time.Second))113									Ω(reporter.End.SuiteSucceeded).Should(BeFalse())114									Ω(reporter.End.SpecReports).Should(ConsistOf(specReportA, specReportB, specReportC))115								})116								It("should signal it's done", func() {117									Ω(server.GetSuiteDone()).Should(BeClosed())118								})119							})120						})121					})122				})123			})124			Describe("supporting ReportEntries (which RPC struggled with when I first implemented it)", func() {125				BeforeEach(func() {126					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())127					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())128					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())129				})130				It("can pass in ReportEntries that include custom types", func() {131					cl := types.NewCodeLocation(0)132					entry, err := internal.NewReportEntry("No Value Entry", cl)133					Ω(err).ShouldNot(HaveOccurred())134					Ω(client.PostDidRun(types.SpecReport{135						LeafNodeText:  "no-value",136						ReportEntries: types.ReportEntries{entry},137					})).Should(Succeed())138					entry, err = internal.NewReportEntry("String Value Entry", cl, "The String")139					Ω(err).ShouldNot(HaveOccurred())140					Ω(client.PostDidRun(types.SpecReport{141						LeafNodeText:  "string-value",142						ReportEntries: types.ReportEntries{entry},143					})).Should(Succeed())144					entry, err = internal.NewReportEntry("Custom Type Value Entry", cl, ColorableStringerStruct{Label: "apples", Count: 17})145					Ω(err).ShouldNot(HaveOccurred())146					Ω(client.PostDidRun(types.SpecReport{147						LeafNodeText:  "custom-value",148						ReportEntries: types.ReportEntries{entry},149					})).Should(Succeed())150					Ω(reporter.Did.Find("no-value").ReportEntries[0].Name).Should(Equal("No Value Entry"))151					Ω(reporter.Did.Find("no-value").ReportEntries[0].StringRepresentation()).Should(Equal(""))152					Ω(reporter.Did.Find("string-value").ReportEntries[0].Name).Should(Equal("String Value Entry"))153					Ω(reporter.Did.Find("string-value").ReportEntries[0].StringRepresentation()).Should(Equal("The String"))154					Ω(reporter.Did.Find("custom-value").ReportEntries[0].Name).Should(Equal("Custom Type Value Entry"))155					Ω(reporter.Did.Find("custom-value").ReportEntries[0].StringRepresentation()).Should(Equal("{{red}}apples {{green}}17{{/}}"))156				})157			})158			Describe("Streaming output", func() {159				It("is configured to stream to stdout", func() {160					server, err := parallel_support.NewServer(3, reporter)161					Ω(err).ShouldNot(HaveOccurred())162					Ω(server.GetOutputDestination().(*os.File).Fd()).Should(Equal(uintptr(1)))163				})164				It("streams output to the provided buffer", func() {165					n, err := client.Write([]byte("hello"))166					Ω(n).Should(Equal(5))167					Ω(err).ShouldNot(HaveOccurred())168					Ω(buffer).Should(gbytes.Say("hello"))169				})170			})171			Describe("Synchronization endpoints", func() {172				var proc1Exited, proc2Exited, proc3Exited chan interface{}173				BeforeEach(func() {174					proc1Exited, proc2Exited, proc3Exited = make(chan interface{}), make(chan interface{}), make(chan interface{})175					aliveFunc := func(c chan interface{}) func() bool {176						return func() bool {177							select {178							case <-c:179								return false180							default:181								return true182							}183						}184					}185					server.RegisterAlive(1, aliveFunc(proc1Exited))186					server.RegisterAlive(2, aliveFunc(proc2Exited))187					server.RegisterAlive(3, aliveFunc(proc3Exited))188				})189				Describe("Managing SynchronizedBeforeSuite synchronization", func() {190					Context("when proc 1 succeeds and returns data", func() {191						It("passes that data along to other procs", func() {192							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, []byte("hello there"))).Should(Succeed())193							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()194							Ω(state).Should(Equal(types.SpecStatePassed))195							Ω(data).Should(Equal([]byte("hello there")))196							Ω(err).ShouldNot(HaveOccurred())197						})198					})199					Context("when proc 1 succeeds and the data happens to be nil", func() {200						It("passes reports success and returns nil", func() {201							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, nil)).Should(Succeed())202							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()203							Ω(state).Should(Equal(types.SpecStatePassed))204							Ω(data).Should(BeNil())205							Ω(err).ShouldNot(HaveOccurred())206						})207					})208					Context("when proc 1 is skipped", func() {209						It("passes that state information along to the other procs", func() {210							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStateSkipped, nil)).Should(Succeed())211							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()212							Ω(state).Should(Equal(types.SpecStateSkipped))213							Ω(data).Should(BeNil())214							Ω(err).ShouldNot(HaveOccurred())215						})216					})217					Context("when proc 1 fails", func() {218						It("passes that state information along to the other procs", func() {219							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStateFailed, nil)).Should(Succeed())220							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()221							Ω(state).Should(Equal(types.SpecStateFailed))222							Ω(data).Should(BeNil())223							Ω(err).ShouldNot(HaveOccurred())224						})225					})226					Context("when proc 1 disappears before reporting back", func() {227						It("returns a meaningful error", func() {228							close(proc1Exited)229							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()230							Ω(state).Should(Equal(types.SpecStateInvalid))231							Ω(data).Should(BeNil())232							Ω(err).Should(MatchError(types.GinkgoErrors.SynchronizedBeforeSuiteDisappearedOnProc1()))233						})234					})235					Context("when proc 1 hasn't responded yet", func() {236						It("blocks until it does", func() {237							done := make(chan interface{})238							go func() {239								defer GinkgoRecover()240								state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()241								Ω(state).Should(Equal(types.SpecStatePassed))242								Ω(data).Should(Equal([]byte("hello there")))243								Ω(err).ShouldNot(HaveOccurred())244								close(done)245							}()246							Consistently(done).ShouldNot(BeClosed())247							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, []byte("hello there"))).Should(Succeed())248							Eventually(done).Should(BeClosed())249						})250					})251				})252				Describe("BlockUntilNonprimaryProcsHaveFinished", func() {253					It("blocks until non-primary procs exit", func() {254						done := make(chan interface{})255						go func() {256							defer GinkgoRecover()257							Ω(client.BlockUntilNonprimaryProcsHaveFinished()).Should(Succeed())258							close(done)259						}()260						Consistently(done).ShouldNot(BeClosed())261						close(proc2Exited)262						Consistently(done).ShouldNot(BeClosed())263						close(proc3Exited)264						Eventually(done).Should(BeClosed())265					})266				})267				Describe("BlockUntilAggregatedNonprimaryProcsReport", func() {268					var specReportA, specReportB types.SpecReport269					var endReport2, endReport3 types.Report270					BeforeEach(func() {271						specReportA = types.SpecReport{LeafNodeText: "A"}272						specReportB = types.SpecReport{LeafNodeText: "B"}273						endReport2 = types.Report{SpecReports: types.SpecReports{specReportA}}274						endReport3 = types.Report{SpecReports: types.SpecReports{specReportB}}275					})276					It("blocks until all non-primary procs exit, then returns the aggregated report", func() {277						done := make(chan interface{})278						go func() {279							defer GinkgoRecover()280							report, err := client.BlockUntilAggregatedNonprimaryProcsReport()281							Ω(err).ShouldNot(HaveOccurred())282							Ω(report.SpecReports).Should(ConsistOf(specReportA, specReportB))283							close(done)284						}()285						Consistently(done).ShouldNot(BeClosed())286						Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())287						close(proc2Exited)288						Consistently(done).ShouldNot(BeClosed())289						Ω(client.PostSuiteDidEnd(endReport3)).Should(Succeed())290						close(proc3Exited)291						Eventually(done).Should(BeClosed())292					})293					Context("when a non-primary proc disappears without reporting back", func() {294						It("blocks returns an appropriate error", func() {295							done := make(chan interface{})296							go func() {297								defer GinkgoRecover()298								report, err := client.BlockUntilAggregatedNonprimaryProcsReport()299								Ω(err).Should(Equal(types.GinkgoErrors.AggregatedReportUnavailableDueToNodeDisappearing()))300								Ω(report).Should(BeZero())301								close(done)302							}()303							Consistently(done).ShouldNot(BeClosed())304							Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())305							close(proc2Exited)306							Consistently(done).ShouldNot(BeClosed())307							close(proc3Exited)308							Eventually(done).Should(BeClosed())309						})310					})311				})312				Describe("Fetching counters", func() {313					It("returns ascending counters", func() {314						Ω(client.FetchNextCounter()).Should(Equal(0))315						Ω(client.FetchNextCounter()).Should(Equal(1))316						Ω(client.FetchNextCounter()).Should(Equal(2))317						Ω(client.FetchNextCounter()).Should(Equal(3))318					})319				})320				Describe("Aborting", func() {321					It("should not abort by default", func() {322						Ω(client.ShouldAbort()).Should(BeFalse())323					})324					Context("when told to abort", func() {325						BeforeEach(func() {326							Ω(client.PostAbort()).Should(Succeed())327						})328						It("should abort", func() {329							Ω(client.ShouldAbort()).Should(BeTrue())330						})331					})332				})333			})334		})335	}336})...

...14	url         string15	bodyType    string16	bodyContent []byte17}18type fakePoster struct {19	posts []post20}21func newFakePoster() *fakePoster {22	return &fakePoster{23		posts: make([]post, 0),24	}25}26func (poster *fakePoster) Post(url string, bodyType string, body io.Reader) (resp *http.Response, err error) {27	bodyContent, _ := io.ReadAll(body)28	poster.posts = append(poster.posts, post{29		url:         url,30		bodyType:    bodyType,31		bodyContent: bodyContent,32	})33	return nil, nil34}...

1import (2func main() {3    fmt.Println("URL:>", url)4    var jsonStr = []byte(`{"name":"test"}`)5    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))6    req.Header.Set("X-Custom-Header", "myvalue")7    req.Header.Set("Content-Type", "application/json")8    client := &http.Client{}9    resp, err := client.Do(req)10    if err != nil {11        panic(err)12    }13    defer resp.Body.Close()14    fmt.Println("response Status:", resp.Status)15    fmt.Println("response Headers:", resp.Header)16    body, _ := ioutil.ReadAll(resp.Body)17    fmt.Println("response Body:", string(body))18}19import (20func main() {21    fmt.Println("URL:>", url)22    req, err := http.NewRequest("GET", url, nil)23    req.Header.Set("X-Custom-Header", "myvalue")24    req.Header.Set("Content-Type", "application/json")25    client := &http.Client{}26    resp, err := client.Do(req)27    if err != nil {28        panic(err)29    }30    defer resp.Body.Close()31    fmt.Println("response Status:", resp.Status)32    fmt.Println("response Headers:", resp.Header)33    body, _ := ioutil.ReadAll(resp.Body)34    fmt.Println("response Body:", string(body))35}36import (37func main() {38    fmt.Println("URL:>", url)39    var jsonStr = []byte(`{"name":"test"}`)40    req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonStr))41    req.Header.Set("X-Custom-Header", "myvalue")42    req.Header.Set("Content-Type", "application/json")43    client := &http.Client{}44    resp, err := client.Do(req)

1import (2func main() {3	payload := strings.NewReader("------WebKitFormBoundary7MA4YWxkTrZu0gW\r4Content-Disposition: form-data; name=\"file\"; filename=\"test.txt\"\r5	client := &http.Client {6	}7	req, err := http.NewRequest(method, url, payload)8	if err != nil {9		fmt.Println(err)10	}11	req.Header.Add("Content-Type", "multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW")12	res, err := client.Do(req)13	defer res.Body.Close()14	body, err := ioutil.ReadAll(res.Body)15	fmt.Println(res)16	fmt.Println(string(body))17}18import (19func main() {20	payload := strings.NewReader("------WebKitFormBoundary7MA4YWxkTrZu0gW\r21Content-Disposition: form-data; name=\"file\"; filename=\"test.txt\"\r22	client := &http.Client {23	}24	req, err := http.NewRequest(method, url, payload)25	if err != nil {26		fmt.Println(err)27	}28	req.Header.Add("Content-Type", "multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW")29	res, err := client.Do(req)30	defer res.Body.Close()31	body, err := ioutil.ReadAll(res.Body)32	fmt.Println(res)33	fmt.Println(string(body))34}35import (36func main() {37	payload := strings.NewReader("------WebKitFormBoundary7MA4YWxkTrZu0gW\r38Content-Disposition: form-data; name=\"file\";

1import (2func main() {3	if err != nil {4	}5	cookie := &http.Cookie{Name: "name", Value: "value"}6	req.AddCookie(cookie)7	data := url.Values{}8	data.Set("name", "value")9	req.Header.Add("If-None-Match", `W/"wyzzy"`)10	client := &http.Client{}11	resp, err := client.Do(req)12	if err != nil {13	}14	fmt.Println(resp)15}16import (17func main() {18	if err != nil {19	}20	cookie := &http.Cookie{Name: "name", Value: "value"}21	req.AddCookie(cookie)22	req.Header.Add("If-None-Match", `W/"wyzzy"`)23	client := &http.Client{}24	resp, err := client.Do(req)25	if err != nil {26	}27	fmt.Println(resp)28}29import (30func main() {31	if err != nil {32	}33	cookie := &http.Cookie{Name: "name", Value: "value"}34	req.AddCookie(cookie)35	req.Header.Add("If-None

1import (2func main() {3	client := &http.Client{}4	data := url.Values{}5	data.Set("name", "manish")6	data.Set("age", "24")7	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")8	resp, _ := client.Do(r)9	fmt.Println("Response status:", resp.Status)10}11import (12func main() {13	fmt.Println("Response status:", resp.Status)14}15import (16func main() {17	fmt.Println("Response status:", resp.Status)18}19import (20func main() {21	client := &http.Client{}22	resp, _ := client.Do(req)23	fmt.Println("Response status:", resp.Status)24}25import (26func main() {27	client := &http.Client{}28	resp, _ := client.Do(req)29	fmt.Println("Response status:", resp.Status)30}31import (32func main() {33	client := &http.Client{}34	resp, _ := client.Do(req)35	fmt.Println("Response status:", resp.Status)36}

1import (2func main() {3	parallel_support_test := parallel_support_test.NewParallelSupportTest()4}5import (6func main() {7	parallel_support_test := parallel_support_test.NewParallelSupportTest()8}9import (10func main() {11	parallel_support_test := parallel_support_test.NewParallelSupportTest()12}13import (14func main() {15	parallel_support_test := parallel_support_test.NewParallelSupportTest()16}17import (18func main() {19	parallel_support_test := parallel_support_test.NewParallelSupportTest()20}21import (22func main() {23	parallel_support_test := parallel_support_test.NewParallelSupportTest()24}

1import (2func main() {3}4import (5func main() {6}7import (8type Response struct {9}10func Get(url string) Response {11	resp, err := http.Get(url)12	if err != nil {13		panic(err)14	}15	defer resp.Body.Close()16	body, err := ioutil.ReadAll(resp.Body)17	if err != nil {18		panic(err)19	}20	return Response{resp.Status, resp.StatusCode, resp.Proto, resp.ProtoMajor, resp.ProtoMinor, resp.Header, body, resp.ContentLength, resp.TransferEncoding, resp.Close, resp.Uncompressed, resp.Trailer, resp.Request, resp.TLS}21}22func Post(url string, contentType string, body []byte) Response {23	resp, err := http.Post(url, contentType, bytes.NewBuffer(body))24	if err != nil {25		panic(err)26	}27	defer resp.Body.Close()28	body, err := ioutil.ReadAll(resp.Body)29	if err != nil {30		panic(err)31	}32	return Response{resp.Status, resp.StatusCode, resp.Proto, resp.ProtoMajor, resp.ProtoMinor, resp.Header

1import "fmt"2import "github.com/parallel_support_test"3import "strconv"4func main() {5    fmt.Println("Post() returned " + strconv.Itoa(p.Get_status_code()))6}7import "fmt"8import "github.com/parallel_support_test"9import "strconv"10func main() {11    fmt.Println("Get() returned " + strconv.Itoa(p.Get_status_code()))12}13import "fmt"14import "github.com/parallel_support_test"15import "strconv"16func main() {17    fmt.Println("Put() returned " + strconv.Itoa(p.Get_status_code()))18}19import "fmt"20import "github.com/parallel_support_test"21import "strconv"22func main() {23    fmt.Println("Delete() returned " + strconv.Itoa(p.Get_status_code()))24}25import "fmt"26import "github.com/parallel_support_test"27import "strconv"28func main() {29    fmt.Println("Head() returned " + strconv.Itoa(p.Get_status_code()))30}31import "fmt"32import "github.com/parallel_support_test"33import "strconv"34func main() {35    fmt.Println("Options() returned " + strconv.Itoa(p.Get_status_code()))36}