func domainWithNoDNSErrors(config ScanQuerierTestConfigFile) { domainsToQueryChannel := make(chan *model.Domain, config.Scan.DomainsBufferSize) domainsToQueryChannel <- &model.Domain{ FQDN: "br.", Nameservers: []model.Nameserver{ { Host: "ns1.br", IPv4: net.ParseIP("127.0.0.1"), }, }, } domainsToQueryChannel <- nil // Poison pill dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) }) domains := runScan(config, domainsToQueryChannel) for _, domain := range domains { if domain.FQDN != "br." || domain.Nameservers[0].LastStatus != model.NameserverStatusOK { utils.Fatalln(fmt.Sprintf("Error checking a well configured DNS domain. "+ "Expected FQDN 'br.' with status %d and got FQDN '%s' with status %d", model.NameserverStatusOK, domain.FQDN, domain.Nameservers[0].LastStatus), nil) } } }
func scanDomain() { dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.example.com.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) }) var client http.Client url := "" if len(config.ShelterConfig.WebClient.Listeners) > 0 { url = fmt.Sprintf("http://%s:%d", config.ShelterConfig.WebClient.Listeners[0].IP, config.ShelterConfig.WebClient.Listeners[0].Port) } if len(url) == 0 { utils.Fatalln("There's no interface to connect to", nil) } content := `{ "Nameservers": [ { "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" } ] }` r, err := http.NewRequest("PUT", fmt.Sprintf("%s%s", url, "/domain/example.com.br./verification"), strings.NewReader(content)) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, []byte(content)) response, err := client.Do(r) if err != nil { utils.Fatalln("Error sending request", err) } responseContent, err := ioutil.ReadAll(response.Body) if err != nil { utils.Fatalln("Error reading response content", err) } if response.StatusCode != http.StatusOK { utils.Fatalln("Error scanning domain", errors.New(string(responseContent))) } var domainResponse protocol.DomainResponse if err := json.Unmarshal(responseContent, &domainResponse); err != nil { utils.Fatalln("Error decoding domain response", err) } if len(domainResponse.Nameservers) != 2 { utils.Fatalln("Wrong number of nameservers", nil) } if domainResponse.Nameservers[0].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) { utils.Fatalln("Scan did not work for ns1", nil) } if domainResponse.Nameservers[1].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) { utils.Fatalln("Scan did not work for ns2", nil) } }
func queryDomain() { dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeNS { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.NS{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 86400, }, Ns: "a.dns.br.", }, &dns.NS{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 86400, }, Ns: "b.dns.br.", }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY { // Empty response dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{}, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) var client http.Client url := "" if len(config.ShelterConfig.WebClient.Listeners) > 0 { url = fmt.Sprintf("http://%s:%d", config.ShelterConfig.WebClient.Listeners[0].IP, config.ShelterConfig.WebClient.Listeners[0].Port) } if len(url) == 0 { utils.Fatalln("There's no interface to connect to", nil) } r, err := http.NewRequest("GET", fmt.Sprintf("%s%s", url, "/domain/example.com.br./verification"), nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) response, err := client.Do(r) if err != nil { utils.Fatalln("Error sending request", err) } responseContent, err := ioutil.ReadAll(response.Body) if err != nil { utils.Fatalln("Error reading response content", err) } if response.StatusCode != http.StatusOK { utils.Fatalln("Error querying domain", errors.New(string(responseContent))) } var domainResponse protocol.DomainResponse if err := json.Unmarshal(responseContent, &domainResponse); err != nil { utils.Fatalln("Error decoding domain response", err) } if len(domainResponse.Nameservers) != 2 { utils.Fatalln("Wrong number of nameservers", nil) } if len(domainResponse.DSSet) != 0 { utils.Fatalln("Wrong number of DS records", nil) } }
// Generates a report with the amount of time of a scan func scanQuerierReport(config ScanQuerierTestConfigFile) { report := " # | Total | QPS | Memory (MB)\n" + "-----------------------------------------------------\n" // Report variables scale := []int{10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000, 1000000, 5000000} fqdn := "domain.com.br." dnskey, rrsig, err := utils.GenerateKSKAndSignZone(fqdn) if err != nil { utils.Fatalln("Error creating DNSSEC keys and signatures", err) } ds := dnskey.ToDS(uint8(model.DSDigestTypeSHA1)) dns.HandleFunc(fqdn, func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: fqdn, Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1." + fqdn, Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ dnskey, rrsig, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) for _, numberOfItems := range scale { var domains []*model.Domain for i := 0; i < numberOfItems; i++ { // We create an object with different nameservers because we don't want to put the // nameserver in the query rate limit check domains = append(domains, &model.Domain{ FQDN: fqdn, Nameservers: []model.Nameserver{ { Host: fmt.Sprintf("ns%d.%s", i, fqdn), IPv4: net.ParseIP("127.0.0.1"), }, }, DSSet: []model.DS{ { Keytag: dnskey.KeyTag(), Algorithm: utils.ConvertKeyAlgorithm(dnskey.Algorithm), DigestType: model.DSDigestTypeSHA1, Digest: ds.Digest, }, }, }) } utils.Println(fmt.Sprintf("Generating report - scale %d", numberOfItems)) totalDuration, queriesPerSecond, _, _ := calculateScanQuerierDurations(config, domains) var memStats runtime.MemStats runtime.ReadMemStats(&memStats) report += fmt.Sprintf("% -8d | %16s | %4d | %14.2f\n", numberOfItems, time.Duration(int64(totalDuration)).String(), queriesPerSecond, float64(memStats.Alloc)/float64(MB), ) } utils.WriteReport(config.Report.ReportFile, report) }
func domainWithNoDNSSECErrors(config ScanQuerierTestConfigFile) { dnskey, rrsig, err := utils.GenerateKSKAndSignZone("br.") if err != nil { utils.Fatalln("Error creating DNSSEC keys and signatures", err) } ds := dnskey.ToDS(uint8(model.DSDigestTypeSHA1)) domainsToQueryChannel := make(chan *model.Domain, config.Scan.DomainsBufferSize) domainsToQueryChannel <- &model.Domain{ FQDN: "br.", Nameservers: []model.Nameserver{ { Host: "ns1.br", IPv4: net.ParseIP("127.0.0.1"), }, }, DSSet: []model.DS{ { Keytag: dnskey.KeyTag(), Algorithm: utils.ConvertKeyAlgorithm(dnskey.Algorithm), DigestType: model.DSDigestTypeSHA1, Digest: ds.Digest, }, }, } domainsToQueryChannel <- nil // Poison pill dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ dnskey, rrsig, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) domains := runScan(config, domainsToQueryChannel) for _, domain := range domains { if domain.FQDN != "br." || domain.DSSet[0].LastStatus != model.DSStatusOK { utils.Fatalln(fmt.Sprintf("Error checking a well configured DNSSEC domain. "+ "Expected FQDN 'br.' with status %d and got FQDN '%s' with status %d", model.DSStatusOK, domain.FQDN, domain.DSSet[0].LastStatus), nil) } } }
func domainQuery() { _, dnskey, rrsig, _, _ := generateAndSignDomain("example.com.br.") dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeNS { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{}, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.NS{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.example.com.br.", }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ dnskey, rrsig, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) dns.HandleFunc("ns1.example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeA { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.A{ Hdr: dns.RR_Header{ Name: "ns1.example.com.br.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 86400, }, A: net.ParseIP("127.0.0.1"), }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeAAAA { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.AAAA{ Hdr: dns.RR_Header{ Name: "ns1.example.com.br.", Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 86400, }, AAAA: net.ParseIP("::1"), }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) domain, err := scan.QueryDomain("example.com.br.") if err != nil { utils.Fatalln("Error resolving a domain", err) } if domain.FQDN != "example.com.br." { utils.Fatalln("Did not set FQDN properly in domain query", nil) } if len(domain.Nameservers) != 1 { println(len(domain.Nameservers)) utils.Fatalln("Did not return the desired nameservers in domain query", nil) } if domain.Nameservers[0].Host != "ns1.example.com.br." { utils.Fatalln("Did not set a valid host in domain query", nil) } if domain.Nameservers[0].IPv4.String() != "127.0.0.1" { utils.Fatalln("Did not set a valid IPv4 in domain query", nil) } if domain.Nameservers[0].IPv6.String() != "::1" { utils.Fatalln("Did not set a valid IPv6 in domain query", nil) } if len(domain.DSSet) != 1 { utils.Fatalln("Did not return the desired DS set in domain query", nil) } if domain.DSSet[0].Keytag != dnskey.KeyTag() { utils.Fatalln("Did not set a valid keytag in domain query", nil) } if domain.DSSet[0].Algorithm != model.DSAlgorithm(dnskey.Algorithm) { utils.Fatalln("Did not set a valid algorithm in domain query", nil) } }
func domainWithNoErrorsOnTheFly() { domain, dnskey, rrsig, lastCheckAt, lastOKAt := generateAndSignDomain("br.") dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY { dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ dnskey, rrsig, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) } }) scan.ScanDomain(&domain) for _, nameserver := range domain.Nameservers { if nameserver.LastStatus != model.NameserverStatusOK { utils.Fatalln(fmt.Sprintf("Fail to validate a supposedly well configured nameserver '%s'. Found status: %s", nameserver.Host, model.NameserverStatusToString(nameserver.LastStatus)), nil) } if nameserver.LastCheckAt.Before(lastCheckAt) || nameserver.LastCheckAt.Equal(lastCheckAt) { utils.Fatalln(fmt.Sprintf("Last check date was not updated in nameserver '%s'", nameserver.Host), nil) } if nameserver.LastOKAt.Before(lastOKAt) || nameserver.LastOKAt.Equal(lastOKAt) { utils.Fatalln(fmt.Sprintf("Last OK date was not updated in nameserver '%s'", nameserver.Host), nil) } } for _, ds := range domain.DSSet { if ds.LastStatus != model.DSStatusOK { utils.Fatalln(fmt.Sprintf("Fail to validate a supposedly well configured DS %d. "+ "Found status: %s", ds.Keytag, model.DSStatusToString(ds.LastStatus)), nil) } if ds.LastCheckAt.Before(lastCheckAt) || ds.LastCheckAt.Equal(lastCheckAt) { utils.Fatalln(fmt.Sprintf("Last check date was not updated in DS %d", ds.Keytag), nil) } if ds.LastOKAt.Before(lastOKAt) || ds.LastOKAt.Equal(lastOKAt) { utils.Fatalln(fmt.Sprintf("Last OK date was not updated in DS %d", ds.Keytag), nil) } } }
func scanDomain() { dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.example.com.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) }) mux := handy.NewHandy() h := new(handler.DomainVerificationHandler) mux.Handle("/domain/{fqdn}/verification", func() handy.Handler { return h }) requestContent := `{ "Nameservers": [ { "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" } ] }` r, err := http.NewRequest("PUT", "/domain/example.com.br./verification", strings.NewReader(requestContent)) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, []byte(requestContent)) w := httptest.NewRecorder() mux.ServeHTTP(w, r) responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln(fmt.Sprintf("Error scanning domain. "+ "Expected %d and got %d", http.StatusOK, w.Code), errors.New(string(responseContent))) } if len(h.Response.Nameservers) != 2 { utils.Fatalln("Wrong number of nameservers", nil) } if h.Response.Nameservers[0].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) { utils.Fatalln("Scan did not work for ns1", nil) } if h.Response.Nameservers[1].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) { utils.Fatalln("Scan did not work for ns2", nil) } }
func queryDomain() { dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{}, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.NS{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 86400, }, Ns: "a.dns.br.", }, &dns.NS{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 86400, }, Ns: "b.dns.br.", }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) }) mux := handy.NewHandy() h := new(handler.DomainVerificationHandler) mux.Handle("/domain/{fqdn}/verification", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/domain/example.com.br./verification", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln(fmt.Sprintf("Error scanning domain. "+ "Expected %d and got %d", http.StatusOK, w.Code), errors.New(string(responseContent))) } if len(h.Response.Nameservers) != 2 { utils.Fatalln("Wrong number of nameservers", nil) } }
func scanPersistedDomain(domainDAO dao.DomainDAO) { dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) { defer w.Close() dnsResponseMessage := &dns.Msg{ MsgHdr: dns.MsgHdr{ Authoritative: true, }, Question: dnsRequestMessage.Question, Answer: []dns.RR{ &dns.SOA{ Hdr: dns.RR_Header{ Name: "example.com.br.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 86400, }, Ns: "ns1.example.com.br.", Mbox: "rafael.justo.net.br.", Serial: 2013112600, Refresh: 86400, Retry: 86400, Expire: 86400, Minttl: 900, }, }, } dnsResponseMessage.SetReply(dnsRequestMessage) w.WriteMsg(dnsResponseMessage) }) mux := handy.NewHandy() h := new(handler.DomainVerificationHandler) mux.Handle("/domain/{fqdn}/verification", func() handy.Handler { return h }) requestContent := `{ "Nameservers": [ { "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" } ] }` domain := model.Domain{ FQDN: "example.com.br.", Nameservers: []model.Nameserver{ { Host: "ns1.example.com.br.", IPv4: net.ParseIP("127.0.0.1"), }, { Host: "ns2.example.com.br.", IPv4: net.ParseIP("127.0.0.1"), }, }, } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln("Error saving domain", err) } r, err := http.NewRequest("PUT", "/domain/example.com.br./verification", strings.NewReader(requestContent)) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, []byte(requestContent)) w := httptest.NewRecorder() mux.ServeHTTP(w, r) responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln(fmt.Sprintf("Error scanning domain. "+ "Expected %d and got %d", http.StatusOK, w.Code), errors.New(string(responseContent))) } domain, err = domainDAO.FindByFQDN(domain.FQDN) if err != nil { utils.Fatalln("Error retrieving the domain", err) } if len(domain.Nameservers) != 2 || domain.Nameservers[0].LastStatus != model.NameserverStatusOK || domain.Nameservers[1].LastStatus != model.NameserverStatusOK { utils.Fatalln("Not updating domain on a scan", nil) } // Now we are going to test when the database domain is different from the scanned domain if err := domainDAO.RemoveByFQDN(domain.FQDN); err != nil { utils.Fatalln("Error removing domain", err) } domain = model.Domain{ FQDN: "example.com.br.", Nameservers: []model.Nameserver{ { Host: "ns1.example.com.br.", IPv4: net.ParseIP("127.0.0.1"), }, { Host: "ns3.example.com.br.", IPv4: net.ParseIP("127.0.0.1"), }, }, } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln("Error saving domain", err) } mux.ServeHTTP(w, r) responseContent, err = ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln(fmt.Sprintf("Error scanning domain. "+ "Expected %d and got %d", http.StatusOK, w.Code), errors.New(string(responseContent))) } domain, err = domainDAO.FindByFQDN(domain.FQDN) if err != nil { utils.Fatalln("Error retrieving the domain", err) } if len(domain.Nameservers) != 2 || domain.Nameservers[0].LastStatus != model.NameserverStatusNotChecked || domain.Nameservers[1].LastStatus != model.NameserverStatusNotChecked { utils.Fatalln("Updating domain on a scan when it shouldn't", nil) } }