func TestSingleton(t *testing.T) { t.Parallel() log1 := GetAuditLogger() test.AssertNotNil(t, log1, "Logger shouldn't be nil") log2 := GetAuditLogger() test.AssertEquals(t, log1, log2) writer, err := syslog.New(syslog.LOG_EMERG|syslog.LOG_KERN, "tag") test.AssertNotError(t, err, "Could not construct syslog object") stats, _ := statsd.NewNoopClient(nil) log3, err := NewAuditLogger(writer, stats) test.AssertNotError(t, err, "Could not construct audit logger") // Should not work err = SetAuditLogger(log3) test.AssertError(t, err, "Can't re-set") // Verify no change log4 := GetAuditLogger() // Verify that log4 != log3 test.AssertNotEquals(t, log4, log3) // Verify that log4 == log2 == log1 test.AssertEquals(t, log4, log2) test.AssertEquals(t, log4, log1) }
func TestReuseAuthorizationDisabled(t *testing.T) { _, sa, ra, _, cleanUp := initAuthorities(t) defer cleanUp() // Turn *off* AuthZ Reuse ra.reuseValidAuthz = false // Create one finalized authorization finalAuthz := AuthzInitial finalAuthz.Status = "valid" exp := ra.clk.Now().Add(365 * 24 * time.Hour) finalAuthz.Expires = &exp finalAuthz.Challenges[0].Status = "valid" finalAuthz.RegistrationID = Registration.ID finalAuthz, err := sa.NewPendingAuthorization(ctx, finalAuthz) test.AssertNotError(t, err, "Could not store test pending authorization") err = sa.FinalizeAuthorization(ctx, finalAuthz) test.AssertNotError(t, err, "Could not finalize test pending authorization") // Now create another authorization for the same Reg.ID/domain secondAuthz, err := ra.NewAuthorization(ctx, AuthzRequest, Registration.ID) test.AssertNotError(t, err, "NewAuthorization for secondAuthz failed") // The second authz should not have the same ID as the previous AuthZ, // because we have set `reuseValidAuthZ` to false. It should be a fresh // & unique authz test.AssertNotEquals(t, finalAuthz.ID, secondAuthz.ID) // The second authz shouldn't be valid, but pending since it is a brand new // authz, not a reused one test.AssertEquals(t, secondAuthz.Status, core.StatusPending) }
func TestProblemDetails(t *testing.T) { pb, err := problemDetailsToPB(nil) test.AssertNotEquals(t, err, "problemDetailToPB failed") test.Assert(t, pb == nil, "Returned corepb.ProblemDetails is not nil") prob := &probs.ProblemDetails{Type: probs.TLSProblem, Detail: "asd", HTTPStatus: 200} pb, err = problemDetailsToPB(prob) test.AssertNotError(t, err, "problemDetailToPB failed") test.Assert(t, pb != nil, "return corepb.ProblemDetails is nill") test.AssertDeepEquals(t, *pb.ProblemType, string(prob.Type)) test.AssertEquals(t, *pb.Detail, prob.Detail) test.AssertEquals(t, int(*pb.HttpStatus), prob.HTTPStatus) recon, err := pbToProblemDetails(pb) test.AssertNotError(t, err, "pbToProblemDetails failed") test.AssertDeepEquals(t, recon, prob) recon, err = pbToProblemDetails(nil) test.AssertNotError(t, err, "pbToProblemDetails failed") test.Assert(t, recon == nil, "Returned core.PRoblemDetails is not nil") _, err = pbToProblemDetails(&corepb.ProblemDetails{}) test.AssertError(t, err, "pbToProblemDetails did not fail") test.AssertEquals(t, err, ErrMissingParameters) empty := "" _, err = pbToProblemDetails(&corepb.ProblemDetails{ProblemType: &empty}) test.AssertError(t, err, "pbToProblemDetails did not fail") test.AssertEquals(t, err, ErrMissingParameters) _, err = pbToProblemDetails(&corepb.ProblemDetails{Detail: &empty}) test.AssertError(t, err, "pbToProblemDetails did not fail") test.AssertEquals(t, err, ErrMissingParameters) }
func TestReuseExpiringAuthorization(t *testing.T) { _, sa, ra, _, cleanUp := initAuthorities(t) defer cleanUp() // Turn on AuthZ Reuse ra.reuseValidAuthz = true // Create one finalized authorization that expires in 12 hours from now expiringAuth := AuthzInitial expiringAuth.Status = "valid" exp := ra.clk.Now().Add(12 * time.Hour) expiringAuth.Expires = &exp expiringAuth.Challenges[0].Status = "valid" expiringAuth.RegistrationID = Registration.ID expiringAuth, err := sa.NewPendingAuthorization(ctx, expiringAuth) test.AssertNotError(t, err, "Could not store test pending authorization") err = sa.FinalizeAuthorization(ctx, expiringAuth) test.AssertNotError(t, err, "Could not finalize test pending authorization") // Now create another authorization for the same Reg.ID/domain secondAuthz, err := ra.NewAuthorization(ctx, AuthzRequest, Registration.ID) test.AssertNotError(t, err, "NewAuthorization for secondAuthz failed") // The second authz should not have the same ID as the previous AuthZ, // because the existing valid authorization expires within 1 day from now test.AssertNotEquals(t, expiringAuth.ID, secondAuthz.ID) // The second authz shouldn't be valid, but pending since it is a brand new // authz, not a reused one test.AssertEquals(t, secondAuthz.Status, core.StatusPending) }
func TestLoadCert(t *testing.T) { testCases := []struct { path string expectedErr string }{ { "", "Issuer certificate was not provided in config.", }, { "../does/not/exist", "open ../does/not/exist: no such file or directory", }, { "../test/test-ca.key", "Invalid certificate value returned", }, } for _, tc := range testCases { _, err := LoadCert(tc.path) test.AssertError(t, err, fmt.Sprintf("LoadCert(%q) did not error", tc.path)) test.AssertEquals(t, err.Error(), tc.expectedErr) } bytes, err := LoadCert("../test/test-ca.pem") test.AssertNotError(t, err, "LoadCert(../test/test-ca.pem) errored") test.AssertNotEquals(t, len(bytes), 0) }
func TestIndex(t *testing.T) { wfe := setupWFE(t) wfe.IndexCacheDuration = time.Second * 10 responseWriter := httptest.NewRecorder() url, _ := url.Parse("/") wfe.Index(responseWriter, &http.Request{ Method: "GET", URL: url, }) test.AssertEquals(t, responseWriter.Code, http.StatusOK) test.AssertNotEquals(t, responseWriter.Body.String(), "404 page not found\n") test.Assert(t, strings.Contains(responseWriter.Body.String(), wfe.NewReg), "new-reg not found") test.AssertEquals(t, responseWriter.Header().Get("Cache-Control"), "public, max-age=10") responseWriter.Body.Reset() responseWriter.Header().Del("Cache-Control") url, _ = url.Parse("/foo") wfe.Index(responseWriter, &http.Request{ URL: url, }) //test.AssertEquals(t, responseWriter.Code, http.StatusNotFound) test.AssertEquals(t, responseWriter.Body.String(), "404 page not found\n") test.AssertEquals(t, responseWriter.Header().Get("Cache-Control"), "") }
func TestHandleFunc(t *testing.T) { wfe := setupWFE(t) var mux *http.ServeMux var rw *httptest.ResponseRecorder var stubCalled bool runWrappedHandler := func(req *http.Request, allowed ...string) { mux = http.NewServeMux() rw = httptest.NewRecorder() stubCalled = false wfe.HandleFunc(mux, "/test", func(http.ResponseWriter, *http.Request) { stubCalled = true }, allowed...) req.URL = mustParseURL("/test") mux.ServeHTTP(rw, req) } // Plain requests (no CORS) type testCase struct { allowed []string reqMethod string shouldSucceed bool } var lastNonce string for _, c := range []testCase{ {[]string{"GET", "POST"}, "GET", true}, {[]string{"GET", "POST"}, "POST", true}, {[]string{"GET"}, "", false}, {[]string{"GET"}, "POST", false}, {[]string{"GET"}, "OPTIONS", false}, // TODO, #469 {[]string{"GET"}, "MAKE-COFFEE", false}, // 405, or 418? } { runWrappedHandler(&http.Request{Method: c.reqMethod}, c.allowed...) test.AssertEquals(t, stubCalled, c.shouldSucceed) if c.shouldSucceed { test.AssertEquals(t, rw.Code, http.StatusOK) } else { test.AssertEquals(t, rw.Code, http.StatusMethodNotAllowed) test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), strings.Join(c.allowed, ", ")) test.AssertEquals(t, rw.Body.String(), `{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`) } nonce := rw.Header().Get("Replay-Nonce") test.AssertNotEquals(t, nonce, lastNonce) lastNonce = nonce } // Disallowed method returns error JSON in body runWrappedHandler(&http.Request{Method: "PUT"}, "GET", "POST") test.AssertEquals(t, rw.Header().Get("Content-Type"), "application/problem+json") test.AssertEquals(t, rw.Body.String(), `{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`) test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST") // Disallowed method special case: response to HEAD has got no body runWrappedHandler(&http.Request{Method: "HEAD"}, "GET", "POST") test.AssertEquals(t, stubCalled, false) test.AssertEquals(t, rw.Body.String(), "") test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST") }
func TestIndex(t *testing.T) { wfe := setupWFE(t) responseWriter := httptest.NewRecorder() url, _ := url.Parse("/") wfe.Index(responseWriter, &http.Request{ Method: "GET", URL: url, }) test.AssertEquals(t, responseWriter.Code, http.StatusOK) test.AssertNotEquals(t, responseWriter.Body.String(), "404 page not found\n") test.Assert(t, strings.Contains(responseWriter.Body.String(), wfe.NewReg), "new-reg not found") responseWriter.Body.Reset() url, _ = url.Parse("/foo") wfe.Index(responseWriter, &http.Request{ URL: url, }) //test.AssertEquals(t, responseWriter.Code, http.StatusNotFound) test.AssertEquals(t, responseWriter.Body.String(), "404 page not found\n") }
func TestSingleton(t *testing.T) { t.Parallel() log1 := Get() test.AssertNotNil(t, log1, "Logger shouldn't be nil") log2 := Get() test.AssertEquals(t, log1, log2) audit := setup(t) // Should not work err := Set(audit) test.AssertError(t, err, "Can't re-set") // Verify no change log4 := Get() // Verify that log4 != log3 test.AssertNotEquals(t, log4, audit) // Verify that log4 == log2 == log1 test.AssertEquals(t, log4, log2) test.AssertEquals(t, log4, log1) }
func TestIndex(t *testing.T) { wfe := NewWebFrontEndImpl() // panic: http: multiple registrations for / [recovered] //wfe.HandlePaths() wfe.NewReg = "/acme/new-reg" responseWriter := httptest.NewRecorder() url, _ := url.Parse("/") wfe.Index(responseWriter, &http.Request{ URL: url, }) test.AssertEquals(t, responseWriter.Code, http.StatusOK) test.AssertNotEquals(t, responseWriter.Body.String(), "404 page not found\n") test.Assert(t, strings.Contains(responseWriter.Body.String(), wfe.NewReg), "new-reg not found") responseWriter.Body.Reset() url, _ = url.Parse("/foo") wfe.Index(responseWriter, &http.Request{ URL: url, }) //test.AssertEquals(t, responseWriter.Code, http.StatusNotFound) test.AssertEquals(t, responseWriter.Body.String(), "404 page not found\n") }