drive_test.go

package onedrive

import (
	"context"
	"fmt"
	"net/http"
	"reflect"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"gotest.tools/v3/assert"
)

var expectedDefaultDrive = &Drive{
	ID:        "0123456789abc",
	DriveType: "personal",
	Owner: &IdentitySet{
		User: &Identity{
			DisplayName: "Gordan Grasarevic",
			ID:          "0123456789abc",
		},
	},
	Quota: &Quota{
		Deleted:   0,
		Remaining: 16095471537,
		State:     "normal",
		Total:     16106127360,
		Used:      10655823,
	},
}

func validFixtureFromDriveID(driveID string) string {
	switch driveID {
	case "", "root":
		return "fixtures/drive.valid.default.json"
	default:
		return fmt.Sprintf("fixtures/drive.valid.%s.json", driveID)
	}
}

func TestDriveURIFromID(t *testing.T) {
	tt := []struct {
		in, out string
	}{
		{"", "/drive"},
		{"123", "/drives/123"},
	}
	for i, tst := range tt {
		if got, want := driveURIFromID(tst.in), tst.out; got != want {
			t.Errorf("[%d] Got %q Expected %q", i, got, want)
		}
	}
}

func TestDriveChildrenURIFromID(t *testing.T) {
	tt := []struct {
		in, out string
	}{
		{"", "/drive/root/children"},
		{"root", "/drive/root/children"},
		{"default", "/drive/root/children"},
		{"test-drive", "/drives/test-drive/root/children"},
	}
	for i, tst := range tt {
		if got, want := driveChildrenURIFromID(tst.in), tst.out; got != want {
			t.Errorf("[%d] Got %q Expected %q", i, got, want)
		}
	}
}

func TestGet(t *testing.T) {
	setup()
	defer teardown()

	tt := []struct {
		driveID        string
		expectedStatus int
		expectedOut    *Drive
	}{
		{"", 200, expectedDefaultDrive},
		{"root", 200, expectedDefaultDrive},
		{"test-id", 200, &Drive{
			ID:        "test-id",
			DriveType: "consumer",
			Owner: &IdentitySet{
				Device: &Identity{
					DisplayName: "test app",
					ID:          "test-id",
				},
			},
			Quota: &Quota{
				Deleted: 1,
			},
		},
		},
	}
	for i, tst := range tt {
		mux.HandleFunc(driveURIFromID(tst.driveID), fileWrapperHandler(validFixtureFromDriveID(tst.driveID), 200))
		drive, _, err := oneDrive.Drives.Get(context.Background(), tst.driveID)
		if err != nil {
			t.Fatalf("Problem fetching the default drive: %s", err.Error())
		}
		if !reflect.DeepEqual(drive, tst.expectedOut) {
			t.Errorf("[%d] Got %v Expected %v", i, drive, tst.expectedOut)
		}
	}
}

func TestGetMissing(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/drives/missing-drive", fileWrapperHandler("fixtures/request.invalid.notFound.json", 404))
	missingDrive, resp, err := oneDrive.Drives.Get(context.Background(), "missing-drive")
	if missingDrive != nil {
		t.Fatalf("A drive was returned when an error was expected: %v", resp)
	}

	expectedErr := &Error{
		Code:    "itemNotFound",
		Message: "Item Does Not Exist",
		InnerError: &Error{
			Code: "itemDoesNotExist",
			InnerError: &Error{
				Code: "folderDoesNotExist",
			},
		},
	}

	if !reflect.DeepEqual(expectedErr, err) {
		t.Errorf("Got %v Expected %v", err, expectedErr)
	}
}

func TestGetMalformed(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/drives/malformed-drive", fileWrapperHandler("fixtures/drive.invalid.malformed.json", 200))
	_, _, err := oneDrive.Drives.Get(context.Background(), "malformed-drive")
	if err == nil {
		t.Fatalf("Expected error, got: %v", err)
	}
}

func TestGetDefault(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/drive", fileWrapperHandler("fixtures/drive.valid.default.json", 200))
	defaultDrive, _, err := oneDrive.Drives.GetDefault(context.Background())
	if err != nil {
		t.Fatalf("Problem fetching the default drive: %s", err.Error())
	}
	if !reflect.DeepEqual(defaultDrive, expectedDefaultDrive) {
		t.Errorf("Got %v Expected %v", defaultDrive, expectedDefaultDrive)
	}
}

func TestListAllDrives(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/drives", fileWrapperHandler("fixtures/drive.collection.valid.json", 200))
	drives, _, err := oneDrive.Drives.ListAll(context.Background())
	if err != nil {
		t.Fatalf("Problem fetching the drive list: %s", err.Error())
	}

	expectedDrives := &Drives{
		Collection: []*Drive{
			expectedDefaultDrive,
		},
	}
	if !reflect.DeepEqual(drives, expectedDrives) {
		t.Errorf("Got %v Expected %v", *drives, *expectedDrives)
	}
}

func TestListAllDrivesInvalid(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/drives", fileWrapperHandler("fixtures/request.invalid.badArgument.json", 400))
	_, resp, err := oneDrive.Drives.ListAll(context.Background())
	if err == nil {
		t.Fatalf("Expected err, got : %v", resp)
	}

	expectedErr := &Error{
		Code:    "invalidArgument",
		Message: "Bad Argument",
		InnerError: &Error{
			Code: "badArgument",
		},
	}

	if !reflect.DeepEqual(err, expectedErr) {
		t.Errorf("Got %v Expected %v", err, expectedErr)
	}
}

func TestListDriveChildren(t *testing.T) {
	setup()
	defer teardown()

	testFolder1 := newItem("Test folder 1", "0123456789abc!104", 9989166)
	testFolder1.Folder = &FolderFacet{
		ChildCount: 10,
	}
	testFolder1.ParentReference = &ItemReference{
		DriveID: "0123456789abc",
		ID:      "0123456789abc!101",
		Path:    "/drive/root:",
	}
	testFolder1.CreatedBy = &IdentitySet{
		Application: appIdentity,
		User:        userIdentity,
	}
	testFolder1.LastModifiedBy = &IdentitySet{
		Application: appIdentity,
		User:        userIdentity,
	}

	mux.HandleFunc(driveChildrenURIFromID(""), fileWrapperHandler("fixtures/drive.children.valid.json", 200))
	items, _, err := oneDrive.Drives.ListChildren(context.Background(), "", "")
	if err != nil {
		t.Fatalf("Problem fetching the drive children: %s", err.Error())
	}

	if got, want := len(items.Collection), 3; got != want {
		t.Fatalf("Got %d, Expected %d children", got, want)
	}

	if got, want := items.Collection[0], testFolder1; !reflect.DeepEqual(got, want) {
		t.Errorf("Got %v Expected %v", *got, *want)
	}
}

func TestListDriveChildrenInvalid(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc(driveChildrenURIFromID(""), fileWrapperHandler("fixtures/drive.children.invalid.json", 200))
	_, resp, err := oneDrive.Drives.ListChildren(context.Background(), "", "")
	if err == nil {
		t.Fatalf("Expected error, got : %v", resp)
	}
}

func TestDriveOptionFiles(t *testing.T) {
	t.Run("when successful response", func(t *testing.T) {
		setup()
		defer teardown()

		mux.HandleFunc("/me/drive/search(q='te%st')", fileWrapperHandler("fixtures/drive.search.valid.json", 200))

		wantItems := &Items{
			Collection: []*Item{
				{
					ID:   "res_1",
					Name: "Test numbers.xlsx",
					CreatedBy: &IdentitySet{
						User: &Identity{
							DisplayName: "Developer",
						},
					},
					LastModifiedBy: &IdentitySet{
						User: &Identity{
							DisplayName: "Developer",
						},
					},
					CreatedDateTime:      time.Date(2019, 9, 23, 14, 20, 38, 0, time.UTC),
					LastModifiedDateTime: time.Date(2019, 9, 23, 14, 21, 51, 0, time.UTC),
					Size:                 8426,
					ParentReference: &ItemReference{
						DriveID: "b!drive1",
						ID:      "ref_1",
					},
					WebURL: "https://test-my.sharepoint.com/personal/test_onmicrosoft_com/_layouts/15/Doc.aspx?sourcedoc=%7res_1%7D&file=Test%20numbers.xlsx&action=default&mobileredirect=true&DefaultItemOpen=1",
					File:   newFileFacet("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", nil),
				},
				{
					ID:   "res_2",
					Name: "Test numbers 2.xlsx",
					CreatedBy: &IdentitySet{
						User: &Identity{
							DisplayName: "Developer",
						},
					},
					LastModifiedBy: &IdentitySet{
						User: &Identity{
							DisplayName: "Developer",
						},
					},
					CreatedDateTime:      time.Date(2019, 9, 23, 14, 20, 38, 0, time.UTC),
					LastModifiedDateTime: time.Date(2019, 9, 23, 14, 21, 51, 0, time.UTC),
					Size:                 5426,
					ParentReference: &ItemReference{
						DriveID: "b!drive1",
						ID:      "ref_1",
					},
					WebURL: "https://test-my.sharepoint.com/personal/test_onmicrosoft_com/_layouts/15/Doc.aspx?sourcedoc=%7res_1%7D&file=Test%20numbers%202.xlsx&action=default&mobileredirect=true&DefaultItemOpen=1",
					File:   newFileFacet("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", nil),
				},
			},
		}

		items, _, err := oneDrive.Drives.Search(context.Background(), DriveOption{Query: "te%st", Scope: MeScope{}})
		if err != nil {
			t.Fatal("unexpected error", err)
		}

		wantCount := 2
		if len(items.Collection) != wantCount {
			t.Errorf("unexpected item count want %d but got %d", wantCount, len(items.Collection))
		}

		if diff := cmp.Diff(wantItems, items); diff != "" {
			t.Error("unexpected diff", diff)
		}
	})

	t.Run("dangerous characters sanitized from query", func(t *testing.T) {
		setup()
		defer teardown()

		mux.HandleFunc("/me/drive/", func(w http.ResponseWriter, r *http.Request) {
			assert.Equal(t, r.URL.Path, "/me/drive/search(q='testtom')")
			fileWrapperHandler("fixtures/drive.search.valid.json", 200)(w, r)
		})

		_, _, err := oneDrive.Drives.Search(context.Background(), DriveOption{Query: "test<tom", Scope: MeScope{}})
		if err != nil {
			t.Fatal(err)
		}
	})

	t.Run("when invalid search criteria", func(t *testing.T) {
		setup()
		defer teardown()

		mux.HandleFunc("/me/drive/search(q='~#')", fileWrapperHandler("fixtures/drive.search.invalid.json", 400))

		_, _, err := oneDrive.Drives.Search(context.Background(), DriveOption{Query: "~#", Scope: MeScope{}})
		if err == nil {
			t.Fatal("expected error but got none")
		}

		wantErr := "A potentially dangerous Request.Path value was detected from the client (*)."
		if err.Error() != wantErr {
			t.Errorf("expected error %s but got %s", wantErr, err.Error())
		}
	})
}