mirror of
https://github.com/rclone/rclone.git
synced 2024-11-29 20:04:52 +01:00
266 lines
7.6 KiB
Go
266 lines
7.6 KiB
Go
// Copyright 2016 Google Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// TODO(jba): test that OnError is getting called appropriately.
|
|
|
|
package logadmin
|
|
|
|
import (
|
|
"flag"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"cloud.google.com/go/internal/testutil"
|
|
"cloud.google.com/go/logging"
|
|
ltesting "cloud.google.com/go/logging/internal/testing"
|
|
"github.com/golang/protobuf/proto"
|
|
"github.com/golang/protobuf/ptypes"
|
|
durpb "github.com/golang/protobuf/ptypes/duration"
|
|
structpb "github.com/golang/protobuf/ptypes/struct"
|
|
"golang.org/x/net/context"
|
|
"google.golang.org/api/option"
|
|
mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
|
|
audit "google.golang.org/genproto/googleapis/cloud/audit"
|
|
logtypepb "google.golang.org/genproto/googleapis/logging/type"
|
|
logpb "google.golang.org/genproto/googleapis/logging/v2"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
var (
|
|
client *Client
|
|
testProjectID string
|
|
)
|
|
|
|
var (
|
|
// If true, this test is using the production service, not a fake.
|
|
integrationTest bool
|
|
|
|
newClient func(ctx context.Context, projectID string) *Client
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
flag.Parse() // needed for testing.Short()
|
|
ctx := context.Background()
|
|
testProjectID = testutil.ProjID()
|
|
if testProjectID == "" || testing.Short() {
|
|
integrationTest = false
|
|
if testProjectID != "" {
|
|
log.Print("Integration tests skipped in short mode (using fake instead)")
|
|
}
|
|
testProjectID = "PROJECT_ID"
|
|
addr, err := ltesting.NewServer()
|
|
if err != nil {
|
|
log.Fatalf("creating fake server: %v", err)
|
|
}
|
|
newClient = func(ctx context.Context, projectID string) *Client {
|
|
conn, err := grpc.Dial(addr, grpc.WithInsecure(), grpc.WithBlock())
|
|
if err != nil {
|
|
log.Fatalf("dialing %q: %v", addr, err)
|
|
}
|
|
c, err := NewClient(ctx, projectID, option.WithGRPCConn(conn))
|
|
if err != nil {
|
|
log.Fatalf("creating client for fake at %q: %v", addr, err)
|
|
}
|
|
return c
|
|
}
|
|
} else {
|
|
integrationTest = true
|
|
ts := testutil.TokenSource(ctx, logging.AdminScope)
|
|
if ts == nil {
|
|
log.Fatal("The project key must be set. See CONTRIBUTING.md for details")
|
|
}
|
|
log.Printf("running integration tests with project %s", testProjectID)
|
|
newClient = func(ctx context.Context, projectID string) *Client {
|
|
c, err := NewClient(ctx, projectID, option.WithTokenSource(ts),
|
|
option.WithGRPCDialOption(grpc.WithBlock()))
|
|
if err != nil {
|
|
log.Fatalf("creating prod client: %v", err)
|
|
}
|
|
return c
|
|
}
|
|
}
|
|
client = newClient(ctx, testProjectID)
|
|
initMetrics(ctx)
|
|
cleanup := initSinks(ctx)
|
|
exit := m.Run()
|
|
cleanup()
|
|
client.Close()
|
|
os.Exit(exit)
|
|
}
|
|
|
|
// EntryIterator and DeleteLog are tested in the logging package.
|
|
|
|
func TestClientClose(t *testing.T) {
|
|
c := newClient(context.Background(), testProjectID)
|
|
if err := c.Close(); err != nil {
|
|
t.Errorf("want got %v, want nil", err)
|
|
}
|
|
}
|
|
|
|
func TestFromLogEntry(t *testing.T) {
|
|
now := time.Now()
|
|
res := &mrpb.MonitoredResource{Type: "global"}
|
|
ts, err := ptypes.TimestampProto(now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
logEntry := logpb.LogEntry{
|
|
LogName: "projects/PROJECT_ID/logs/LOG_ID",
|
|
Resource: res,
|
|
Payload: &logpb.LogEntry_TextPayload{TextPayload: "hello"},
|
|
Timestamp: ts,
|
|
Severity: logtypepb.LogSeverity_INFO,
|
|
InsertId: "123",
|
|
HttpRequest: &logtypepb.HttpRequest{
|
|
RequestMethod: "GET",
|
|
RequestUrl: "http:://example.com/path?q=1",
|
|
RequestSize: 100,
|
|
Status: 200,
|
|
ResponseSize: 25,
|
|
Latency: &durpb.Duration{Seconds: 100},
|
|
UserAgent: "user-agent",
|
|
RemoteIp: "127.0.0.1",
|
|
Referer: "referer",
|
|
CacheHit: true,
|
|
CacheValidatedWithOriginServer: true,
|
|
},
|
|
Labels: map[string]string{
|
|
"a": "1",
|
|
"b": "two",
|
|
"c": "true",
|
|
},
|
|
}
|
|
u, err := url.Parse("http:://example.com/path?q=1")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := &logging.Entry{
|
|
LogName: "projects/PROJECT_ID/logs/LOG_ID",
|
|
Resource: res,
|
|
Timestamp: now.In(time.UTC),
|
|
Severity: logging.Info,
|
|
Payload: "hello",
|
|
Labels: map[string]string{
|
|
"a": "1",
|
|
"b": "two",
|
|
"c": "true",
|
|
},
|
|
InsertID: "123",
|
|
HTTPRequest: &logging.HTTPRequest{
|
|
Request: &http.Request{
|
|
Method: "GET",
|
|
URL: u,
|
|
Header: map[string][]string{
|
|
"User-Agent": []string{"user-agent"},
|
|
"Referer": []string{"referer"},
|
|
},
|
|
},
|
|
RequestSize: 100,
|
|
Status: 200,
|
|
ResponseSize: 25,
|
|
Latency: 100 * time.Second,
|
|
RemoteIP: "127.0.0.1",
|
|
CacheHit: true,
|
|
CacheValidatedWithOriginServer: true,
|
|
},
|
|
}
|
|
got, err := fromLogEntry(&logEntry)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if diff := testutil.Diff(got, want, testutil.IgnoreUnexported(http.Request{})); diff != "" {
|
|
t.Errorf("FullEntry:\n%s", diff)
|
|
}
|
|
|
|
// Proto payload.
|
|
alog := &audit.AuditLog{
|
|
ServiceName: "svc",
|
|
MethodName: "method",
|
|
ResourceName: "shelves/S/books/B",
|
|
}
|
|
any, err := ptypes.MarshalAny(alog)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
logEntry = logpb.LogEntry{
|
|
LogName: "projects/PROJECT_ID/logs/LOG_ID",
|
|
Resource: res,
|
|
Timestamp: ts,
|
|
Payload: &logpb.LogEntry_ProtoPayload{ProtoPayload: any},
|
|
}
|
|
got, err = fromLogEntry(&logEntry)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !ltesting.PayloadEqual(got.Payload, alog) {
|
|
t.Errorf("got %+v, want %+v", got.Payload, alog)
|
|
}
|
|
|
|
// JSON payload.
|
|
jstruct := &structpb.Struct{Fields: map[string]*structpb.Value{
|
|
"f": &structpb.Value{Kind: &structpb.Value_NumberValue{NumberValue: 3.1}},
|
|
}}
|
|
logEntry = logpb.LogEntry{
|
|
LogName: "projects/PROJECT_ID/logs/LOG_ID",
|
|
Resource: res,
|
|
Timestamp: ts,
|
|
Payload: &logpb.LogEntry_JsonPayload{JsonPayload: jstruct},
|
|
}
|
|
got, err = fromLogEntry(&logEntry)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !ltesting.PayloadEqual(got.Payload, jstruct) {
|
|
t.Errorf("got %+v, want %+v", got.Payload, jstruct)
|
|
}
|
|
}
|
|
|
|
func TestListLogEntriesRequest(t *testing.T) {
|
|
for _, test := range []struct {
|
|
opts []EntriesOption
|
|
projectIDs []string
|
|
filter string
|
|
orderBy string
|
|
}{
|
|
// Default is client's project ID, empty filter and orderBy.
|
|
{nil,
|
|
[]string{"PROJECT_ID"}, "", ""},
|
|
{[]EntriesOption{NewestFirst(), Filter("f")},
|
|
[]string{"PROJECT_ID"}, "f", "timestamp desc"},
|
|
{[]EntriesOption{ProjectIDs([]string{"foo"})},
|
|
[]string{"foo"}, "", ""},
|
|
{[]EntriesOption{NewestFirst(), Filter("f"), ProjectIDs([]string{"foo"})},
|
|
[]string{"foo"}, "f", "timestamp desc"},
|
|
{[]EntriesOption{NewestFirst(), Filter("f"), ProjectIDs([]string{"foo"})},
|
|
[]string{"foo"}, "f", "timestamp desc"},
|
|
// If there are repeats, last one wins.
|
|
{[]EntriesOption{NewestFirst(), Filter("no"), ProjectIDs([]string{"foo"}), Filter("f")},
|
|
[]string{"foo"}, "f", "timestamp desc"},
|
|
} {
|
|
got := listLogEntriesRequest("PROJECT_ID", test.opts)
|
|
want := &logpb.ListLogEntriesRequest{
|
|
ResourceNames: []string{"projects/" + test.projectIDs[0]},
|
|
Filter: test.filter,
|
|
OrderBy: test.orderBy,
|
|
}
|
|
if !proto.Equal(got, want) {
|
|
t.Errorf("%v:\ngot %v\nwant %v", test.opts, got, want)
|
|
}
|
|
}
|
|
}
|