diff --git a/services/collaboration/mocks/content_connector_service.go b/services/collaboration/mocks/content_connector_service.go
index 9b034f5da..da6ff575c 100644
--- a/services/collaboration/mocks/content_connector_service.go
+++ b/services/collaboration/mocks/content_connector_service.go
@@ -4,6 +4,9 @@ package mocks
 
 import (
 	context "context"
+
+	connector "github.com/owncloud/ocis/v2/services/collaboration/pkg/connector"
+
 	io "io"
 
 	mock "github.com/stretchr/testify/mock"
@@ -70,22 +73,24 @@ func (_c *ContentConnectorService_GetFile_Call) RunAndReturn(run func(context.Co
 }
 
 // PutFile provides a mock function with given fields: ctx, stream, streamLength, lockID
-func (_m *ContentConnectorService) PutFile(ctx context.Context, stream io.Reader, streamLength int64, lockID string) (string, error) {
+func (_m *ContentConnectorService) PutFile(ctx context.Context, stream io.Reader, streamLength int64, lockID string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, stream, streamLength, lockID)
 
 	if len(ret) == 0 {
 		panic("no return value specified for PutFile")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, int64, string) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, int64, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, stream, streamLength, lockID)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, int64, string) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, int64, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, stream, streamLength, lockID)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context, io.Reader, int64, string) error); ok {
@@ -118,12 +123,12 @@ func (_c *ContentConnectorService_PutFile_Call) Run(run func(ctx context.Context
 	return _c
 }
 
-func (_c *ContentConnectorService_PutFile_Call) Return(_a0 string, _a1 error) *ContentConnectorService_PutFile_Call {
+func (_c *ContentConnectorService_PutFile_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *ContentConnectorService_PutFile_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *ContentConnectorService_PutFile_Call) RunAndReturn(run func(context.Context, io.Reader, int64, string) (string, error)) *ContentConnectorService_PutFile_Call {
+func (_c *ContentConnectorService_PutFile_Call) RunAndReturn(run func(context.Context, io.Reader, int64, string) (*connector.ConnectorResponse, error)) *ContentConnectorService_PutFile_Call {
 	_c.Call.Return(run)
 	return _c
 }
diff --git a/services/collaboration/mocks/file_connector_service.go b/services/collaboration/mocks/file_connector_service.go
index 9518dd36a..b822ed2e2 100644
--- a/services/collaboration/mocks/file_connector_service.go
+++ b/services/collaboration/mocks/file_connector_service.go
@@ -7,8 +7,6 @@ import (
 
 	connector "github.com/owncloud/ocis/v2/services/collaboration/pkg/connector"
 
-	fileinfo "github.com/owncloud/ocis/v2/services/collaboration/pkg/connector/fileinfo"
-
 	io "io"
 
 	mock "github.com/stretchr/testify/mock"
@@ -28,23 +26,23 @@ func (_m *FileConnectorService) EXPECT() *FileConnectorService_Expecter {
 }
 
 // CheckFileInfo provides a mock function with given fields: ctx
-func (_m *FileConnectorService) CheckFileInfo(ctx context.Context) (fileinfo.FileInfo, error) {
+func (_m *FileConnectorService) CheckFileInfo(ctx context.Context) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx)
 
 	if len(ret) == 0 {
 		panic("no return value specified for CheckFileInfo")
 	}
 
-	var r0 fileinfo.FileInfo
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (fileinfo.FileInfo, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context) fileinfo.FileInfo); ok {
+	if rf, ok := ret.Get(0).(func(context.Context) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(fileinfo.FileInfo)
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
 		}
 	}
 
@@ -75,33 +73,35 @@ func (_c *FileConnectorService_CheckFileInfo_Call) Run(run func(ctx context.Cont
 	return _c
 }
 
-func (_c *FileConnectorService_CheckFileInfo_Call) Return(_a0 fileinfo.FileInfo, _a1 error) *FileConnectorService_CheckFileInfo_Call {
+func (_c *FileConnectorService_CheckFileInfo_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_CheckFileInfo_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_CheckFileInfo_Call) RunAndReturn(run func(context.Context) (fileinfo.FileInfo, error)) *FileConnectorService_CheckFileInfo_Call {
+func (_c *FileConnectorService_CheckFileInfo_Call) RunAndReturn(run func(context.Context) (*connector.ConnectorResponse, error)) *FileConnectorService_CheckFileInfo_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // DeleteFile provides a mock function with given fields: ctx, lockID
-func (_m *FileConnectorService) DeleteFile(ctx context.Context, lockID string) (string, error) {
+func (_m *FileConnectorService) DeleteFile(ctx context.Context, lockID string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, lockID)
 
 	if len(ret) == 0 {
 		panic("no return value specified for DeleteFile")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, lockID)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, string) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, lockID)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
@@ -132,33 +132,35 @@ func (_c *FileConnectorService_DeleteFile_Call) Run(run func(ctx context.Context
 	return _c
 }
 
-func (_c *FileConnectorService_DeleteFile_Call) Return(_a0 string, _a1 error) *FileConnectorService_DeleteFile_Call {
+func (_c *FileConnectorService_DeleteFile_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_DeleteFile_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_DeleteFile_Call) RunAndReturn(run func(context.Context, string) (string, error)) *FileConnectorService_DeleteFile_Call {
+func (_c *FileConnectorService_DeleteFile_Call) RunAndReturn(run func(context.Context, string) (*connector.ConnectorResponse, error)) *FileConnectorService_DeleteFile_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // GetLock provides a mock function with given fields: ctx
-func (_m *FileConnectorService) GetLock(ctx context.Context) (string, error) {
+func (_m *FileConnectorService) GetLock(ctx context.Context) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetLock")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
@@ -188,33 +190,35 @@ func (_c *FileConnectorService_GetLock_Call) Run(run func(ctx context.Context))
 	return _c
 }
 
-func (_c *FileConnectorService_GetLock_Call) Return(_a0 string, _a1 error) *FileConnectorService_GetLock_Call {
+func (_c *FileConnectorService_GetLock_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_GetLock_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_GetLock_Call) RunAndReturn(run func(context.Context) (string, error)) *FileConnectorService_GetLock_Call {
+func (_c *FileConnectorService_GetLock_Call) RunAndReturn(run func(context.Context) (*connector.ConnectorResponse, error)) *FileConnectorService_GetLock_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Lock provides a mock function with given fields: ctx, lockID, oldLockID
-func (_m *FileConnectorService) Lock(ctx context.Context, lockID string, oldLockID string) (string, error) {
+func (_m *FileConnectorService) Lock(ctx context.Context, lockID string, oldLockID string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, lockID, oldLockID)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Lock")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, lockID, oldLockID)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, lockID, oldLockID)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
@@ -246,53 +250,44 @@ func (_c *FileConnectorService_Lock_Call) Run(run func(ctx context.Context, lock
 	return _c
 }
 
-func (_c *FileConnectorService_Lock_Call) Return(_a0 string, _a1 error) *FileConnectorService_Lock_Call {
+func (_c *FileConnectorService_Lock_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_Lock_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_Lock_Call) RunAndReturn(run func(context.Context, string, string) (string, error)) *FileConnectorService_Lock_Call {
+func (_c *FileConnectorService_Lock_Call) RunAndReturn(run func(context.Context, string, string) (*connector.ConnectorResponse, error)) *FileConnectorService_Lock_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // PutRelativeFileRelative provides a mock function with given fields: ctx, ccs, stream, streamLength, target
-func (_m *FileConnectorService) PutRelativeFileRelative(ctx context.Context, ccs connector.ContentConnectorService, stream io.Reader, streamLength int64, target string) (*connector.PutRelativeResponse, *connector.PutRelativeHeaders, error) {
+func (_m *FileConnectorService) PutRelativeFileRelative(ctx context.Context, ccs connector.ContentConnectorService, stream io.Reader, streamLength int64, target string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, ccs, stream, streamLength, target)
 
 	if len(ret) == 0 {
 		panic("no return value specified for PutRelativeFileRelative")
 	}
 
-	var r0 *connector.PutRelativeResponse
-	var r1 *connector.PutRelativeHeaders
-	var r2 error
-	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.PutRelativeResponse, *connector.PutRelativeHeaders, error)); ok {
+	var r0 *connector.ConnectorResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, ccs, stream, streamLength, target)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) *connector.PutRelativeResponse); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, ccs, stream, streamLength, target)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*connector.PutRelativeResponse)
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) *connector.PutRelativeHeaders); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) error); ok {
 		r1 = rf(ctx, ccs, stream, streamLength, target)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*connector.PutRelativeHeaders)
-		}
+		r1 = ret.Error(1)
 	}
 
-	if rf, ok := ret.Get(2).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) error); ok {
-		r2 = rf(ctx, ccs, stream, streamLength, target)
-	} else {
-		r2 = ret.Error(2)
-	}
-
-	return r0, r1, r2
+	return r0, r1
 }
 
 // FileConnectorService_PutRelativeFileRelative_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRelativeFileRelative'
@@ -317,34 +312,34 @@ func (_c *FileConnectorService_PutRelativeFileRelative_Call) Run(run func(ctx co
 	return _c
 }
 
-func (_c *FileConnectorService_PutRelativeFileRelative_Call) Return(_a0 *connector.PutRelativeResponse, _a1 *connector.PutRelativeHeaders, _a2 error) *FileConnectorService_PutRelativeFileRelative_Call {
-	_c.Call.Return(_a0, _a1, _a2)
+func (_c *FileConnectorService_PutRelativeFileRelative_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_PutRelativeFileRelative_Call {
+	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_PutRelativeFileRelative_Call) RunAndReturn(run func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.PutRelativeResponse, *connector.PutRelativeHeaders, error)) *FileConnectorService_PutRelativeFileRelative_Call {
+func (_c *FileConnectorService_PutRelativeFileRelative_Call) RunAndReturn(run func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.ConnectorResponse, error)) *FileConnectorService_PutRelativeFileRelative_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // PutRelativeFileSuggested provides a mock function with given fields: ctx, ccs, stream, streamLength, target
-func (_m *FileConnectorService) PutRelativeFileSuggested(ctx context.Context, ccs connector.ContentConnectorService, stream io.Reader, streamLength int64, target string) (*connector.PutRelativeResponse, error) {
+func (_m *FileConnectorService) PutRelativeFileSuggested(ctx context.Context, ccs connector.ContentConnectorService, stream io.Reader, streamLength int64, target string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, ccs, stream, streamLength, target)
 
 	if len(ret) == 0 {
 		panic("no return value specified for PutRelativeFileSuggested")
 	}
 
-	var r0 *connector.PutRelativeResponse
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.PutRelativeResponse, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, ccs, stream, streamLength, target)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) *connector.PutRelativeResponse); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, ccs, stream, streamLength, target)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*connector.PutRelativeResponse)
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
 		}
 	}
 
@@ -379,33 +374,35 @@ func (_c *FileConnectorService_PutRelativeFileSuggested_Call) Run(run func(ctx c
 	return _c
 }
 
-func (_c *FileConnectorService_PutRelativeFileSuggested_Call) Return(_a0 *connector.PutRelativeResponse, _a1 error) *FileConnectorService_PutRelativeFileSuggested_Call {
+func (_c *FileConnectorService_PutRelativeFileSuggested_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_PutRelativeFileSuggested_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_PutRelativeFileSuggested_Call) RunAndReturn(run func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.PutRelativeResponse, error)) *FileConnectorService_PutRelativeFileSuggested_Call {
+func (_c *FileConnectorService_PutRelativeFileSuggested_Call) RunAndReturn(run func(context.Context, connector.ContentConnectorService, io.Reader, int64, string) (*connector.ConnectorResponse, error)) *FileConnectorService_PutRelativeFileSuggested_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RefreshLock provides a mock function with given fields: ctx, lockID
-func (_m *FileConnectorService) RefreshLock(ctx context.Context, lockID string) (string, error) {
+func (_m *FileConnectorService) RefreshLock(ctx context.Context, lockID string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, lockID)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RefreshLock")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, lockID)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, string) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, lockID)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
@@ -436,51 +433,44 @@ func (_c *FileConnectorService_RefreshLock_Call) Run(run func(ctx context.Contex
 	return _c
 }
 
-func (_c *FileConnectorService_RefreshLock_Call) Return(_a0 string, _a1 error) *FileConnectorService_RefreshLock_Call {
+func (_c *FileConnectorService_RefreshLock_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_RefreshLock_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_RefreshLock_Call) RunAndReturn(run func(context.Context, string) (string, error)) *FileConnectorService_RefreshLock_Call {
+func (_c *FileConnectorService_RefreshLock_Call) RunAndReturn(run func(context.Context, string) (*connector.ConnectorResponse, error)) *FileConnectorService_RefreshLock_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RenameFile provides a mock function with given fields: ctx, lockID, target
-func (_m *FileConnectorService) RenameFile(ctx context.Context, lockID string, target string) (*connector.RenameResponse, string, error) {
+func (_m *FileConnectorService) RenameFile(ctx context.Context, lockID string, target string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, lockID, target)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RenameFile")
 	}
 
-	var r0 *connector.RenameResponse
-	var r1 string
-	var r2 error
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*connector.RenameResponse, string, error)); ok {
+	var r0 *connector.ConnectorResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, lockID, target)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, string, string) *connector.RenameResponse); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, lockID, target)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*connector.RenameResponse)
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, string, string) string); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
 		r1 = rf(ctx, lockID, target)
 	} else {
-		r1 = ret.Get(1).(string)
+		r1 = ret.Error(1)
 	}
 
-	if rf, ok := ret.Get(2).(func(context.Context, string, string) error); ok {
-		r2 = rf(ctx, lockID, target)
-	} else {
-		r2 = ret.Error(2)
-	}
-
-	return r0, r1, r2
+	return r0, r1
 }
 
 // FileConnectorService_RenameFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameFile'
@@ -503,33 +493,35 @@ func (_c *FileConnectorService_RenameFile_Call) Run(run func(ctx context.Context
 	return _c
 }
 
-func (_c *FileConnectorService_RenameFile_Call) Return(_a0 *connector.RenameResponse, _a1 string, _a2 error) *FileConnectorService_RenameFile_Call {
-	_c.Call.Return(_a0, _a1, _a2)
+func (_c *FileConnectorService_RenameFile_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_RenameFile_Call {
+	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_RenameFile_Call) RunAndReturn(run func(context.Context, string, string) (*connector.RenameResponse, string, error)) *FileConnectorService_RenameFile_Call {
+func (_c *FileConnectorService_RenameFile_Call) RunAndReturn(run func(context.Context, string, string) (*connector.ConnectorResponse, error)) *FileConnectorService_RenameFile_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UnLock provides a mock function with given fields: ctx, lockID
-func (_m *FileConnectorService) UnLock(ctx context.Context, lockID string) (string, error) {
+func (_m *FileConnectorService) UnLock(ctx context.Context, lockID string) (*connector.ConnectorResponse, error) {
 	ret := _m.Called(ctx, lockID)
 
 	if len(ret) == 0 {
 		panic("no return value specified for UnLock")
 	}
 
-	var r0 string
+	var r0 *connector.ConnectorResponse
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) (*connector.ConnectorResponse, error)); ok {
 		return rf(ctx, lockID)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, string) string); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string) *connector.ConnectorResponse); ok {
 		r0 = rf(ctx, lockID)
 	} else {
-		r0 = ret.Get(0).(string)
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*connector.ConnectorResponse)
+		}
 	}
 
 	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
@@ -560,12 +552,12 @@ func (_c *FileConnectorService_UnLock_Call) Run(run func(ctx context.Context, lo
 	return _c
 }
 
-func (_c *FileConnectorService_UnLock_Call) Return(_a0 string, _a1 error) *FileConnectorService_UnLock_Call {
+func (_c *FileConnectorService_UnLock_Call) Return(_a0 *connector.ConnectorResponse, _a1 error) *FileConnectorService_UnLock_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *FileConnectorService_UnLock_Call) RunAndReturn(run func(context.Context, string) (string, error)) *FileConnectorService_UnLock_Call {
+func (_c *FileConnectorService_UnLock_Call) RunAndReturn(run func(context.Context, string) (*connector.ConnectorResponse, error)) *FileConnectorService_UnLock_Call {
 	_c.Call.Return(run)
 	return _c
 }
diff --git a/services/collaboration/pkg/connector/contentconnector_test.go b/services/collaboration/pkg/connector/contentconnector_test.go
index aaf9fecf7..38f308afc 100644
--- a/services/collaboration/pkg/connector/contentconnector_test.go
+++ b/services/collaboration/pkg/connector/contentconnector_test.go
@@ -220,9 +220,9 @@ var _ = Describe("ContentConnector", func() {
 		It("No valid context", func() {
 			reader := strings.NewReader("Content to upload is here!")
 			ctx := context.Background()
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Stat call failed", func() {
@@ -234,9 +234,9 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewInternal(ctx, "Something failed"),
 			}, targetErr)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Stat call status not ok", func() {
@@ -247,11 +247,10 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewInternal(ctx, "Something failed"),
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Mismatched lockId", func() {
@@ -268,11 +267,10 @@ var _ = Describe("ContentConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal("goodAndValidLock"))
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "notARandomLockId")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("goodAndValidLock"))
 		})
 
 		It("Upload without lockId but on a non empty file", func() {
@@ -287,11 +285,10 @@ var _ = Describe("ContentConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal(""))
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal(""))
 		})
 
 		It("Initiate upload fails", func() {
@@ -314,9 +311,9 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewInternal(ctx, "Something failed"),
 			}, targetErr)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Initiate upload status not ok", func() {
@@ -338,11 +335,10 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewInternal(ctx, "Something failed"),
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Empty upload successful", func() {
@@ -364,9 +360,10 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
 			Expect(err).To(Succeed())
-			Expect(newLockId).To(Equal(""))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Missing upload endpoint", func() {
@@ -388,11 +385,10 @@ var _ = Describe("ContentConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			Expect(err).To(BeNil())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("upload request failed", func() {
@@ -420,12 +416,11 @@ var _ = Describe("ContentConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
 			Expect(srvReqHeader.Get("X-Access-Token")).To(Equal(wopiCtx.AccessToken))
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("upload request success", func() {
@@ -453,10 +448,11 @@ var _ = Describe("ContentConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
+			response, err := cc.PutFile(ctx, reader, reader.Size(), "goodAndValidLock")
 			Expect(srvReqHeader.Get("X-Access-Token")).To(Equal(wopiCtx.AccessToken))
 			Expect(err).To(Succeed())
-			Expect(newLockId).To(Equal(""))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
 		})
 	})
 })
diff --git a/services/collaboration/pkg/connector/fileconnector_test.go b/services/collaboration/pkg/connector/fileconnector_test.go
index d6f88c5ad..aeb303bc1 100644
--- a/services/collaboration/pkg/connector/fileconnector_test.go
+++ b/services/collaboration/pkg/connector/fileconnector_test.go
@@ -91,9 +91,9 @@ var _ = Describe("FileConnector", func() {
 	Describe("GetLock", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			newLockId, err := fc.GetLock(ctx)
+			response, err := fc.GetLock(ctx)
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Get lock failed", func() {
@@ -104,9 +104,9 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "Something failed"),
 			}, targetErr)
 
-			newLockId, err := fc.GetLock(ctx)
+			response, err := fc.GetLock(ctx)
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Get lock failed status not ok", func() {
@@ -117,11 +117,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewNotFound(ctx, "File is missing"),
 			}, nil)
 
-			newLockId, err := fc.GetLock(ctx)
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(404))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.GetLock(ctx)
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(404))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Get lock success", func() {
@@ -136,9 +135,10 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := fc.GetLock(ctx)
+			response, err := fc.GetLock(ctx)
 			Expect(err).To(Succeed())
-			Expect(newLockId).To(Equal("zzz999"))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 		})
 	})
 
@@ -146,19 +146,18 @@ var _ = Describe("FileConnector", func() {
 		Describe("Lock", func() {
 			It("No valid context", func() {
 				ctx := context.Background()
-				newLockId, err := fc.Lock(ctx, "newLock", "")
+				response, err := fc.Lock(ctx, "newLock", "")
 				Expect(err).To(HaveOccurred())
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Empty lockId", func() {
 				ctx := middleware.WopiContextToCtx(context.Background(), wopiCtx)
 
-				newLockId, err := fc.Lock(ctx, "", "")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(400))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "", "")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(400))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Set lock failed", func() {
@@ -169,10 +168,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInternal(ctx, "Something failed"),
 				}, targetErr)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
+				response, err := fc.Lock(ctx, "abcdef123", "")
 				Expect(err).To(HaveOccurred())
 				Expect(err).To(Equal(targetErr))
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Set lock success", func() {
@@ -182,9 +181,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewOK(ctx),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
+				response, err := fc.Lock(ctx, "abcdef123", "")
 				Expect(err).To(Succeed())
-				Expect(newLockId).To(Equal(""))
+				Expect(response.Status).To(Equal(200))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Set lock mismatches error getting lock", func() {
@@ -199,10 +199,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInternal(ctx, "lock mismatch"),
 				}, targetErr)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
+				response, err := fc.Lock(ctx, "abcdef123", "")
 				Expect(err).To(HaveOccurred())
 				Expect(err).To(Equal(targetErr))
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Set lock mismatches", func() {
@@ -220,11 +220,10 @@ var _ = Describe("FileConnector", func() {
 					},
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(409))
-				Expect(newLockId).To(Equal("zzz999"))
+				response, err := fc.Lock(ctx, "abcdef123", "")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(409))
+				Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 			})
 
 			It("Set lock mismatches but get lock matches", func() {
@@ -242,9 +241,10 @@ var _ = Describe("FileConnector", func() {
 					},
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
+				response, err := fc.Lock(ctx, "abcdef123", "")
 				Expect(err).To(Succeed())
-				Expect(newLockId).To(Equal("abcdef123"))
+				Expect(response.Status).To(Equal(200))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Set lock mismatches but get lock doesn't return lockId", func() {
@@ -258,11 +258,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewOK(ctx),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(500))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(500))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("File not found", func() {
@@ -272,11 +271,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewNotFound(ctx, "file not found"),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(404))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(404))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Default error handling (insufficient storage)", func() {
@@ -286,30 +284,28 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInsufficientStorage(ctx, nil, "file too big"),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(500))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(500))
+				Expect(response.Headers).To(BeNil())
 			})
 		})
 
 		Describe("Unlock and relock", func() {
 			It("No valid context", func() {
 				ctx := context.Background()
-				newLockId, err := fc.Lock(ctx, "newLock", "oldLock")
+				response, err := fc.Lock(ctx, "newLock", "oldLock")
 				Expect(err).To(HaveOccurred())
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Empty lockId", func() {
 				ctx := middleware.WopiContextToCtx(context.Background(), wopiCtx)
 
-				newLockId, err := fc.Lock(ctx, "", "oldLock")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(400))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "", "oldLock")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(400))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Refresh lock failed", func() {
@@ -320,10 +316,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInternal(ctx, "Something failed"),
 				}, targetErr)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "oldLock")
+				response, err := fc.Lock(ctx, "abcdef123", "oldLock")
 				Expect(err).To(HaveOccurred())
 				Expect(err).To(Equal(targetErr))
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Refresh lock success", func() {
@@ -333,9 +329,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewOK(ctx),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "oldLock")
+				response, err := fc.Lock(ctx, "abcdef123", "oldLock")
 				Expect(err).To(Succeed())
-				Expect(newLockId).To(Equal(""))
+				Expect(response.Status).To(Equal(200))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Refresh lock mismatches error getting lock", func() {
@@ -350,10 +347,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInternal(ctx, "lock mismatch"),
 				}, targetErr)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
 				Expect(err).To(HaveOccurred())
 				Expect(err).To(Equal(targetErr))
-				Expect(newLockId).To(Equal(""))
+				Expect(response).To(BeNil())
 			})
 
 			It("Refresh lock mismatches", func() {
@@ -371,11 +368,10 @@ var _ = Describe("FileConnector", func() {
 					},
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(409))
-				Expect(newLockId).To(Equal("zzz999"))
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(409))
+				Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 			})
 
 			It("Refresh lock mismatches but get lock matches", func() {
@@ -393,9 +389,10 @@ var _ = Describe("FileConnector", func() {
 					},
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
 				Expect(err).To(Succeed())
-				Expect(newLockId).To(Equal("abcdef123"))
+				Expect(response.Status).To(Equal(200))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Refresh lock mismatches but get lock doesn't return lockId", func() {
@@ -409,11 +406,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewOK(ctx),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(500))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(500))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("File not found", func() {
@@ -423,11 +419,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewNotFound(ctx, "file not found"),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(404))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(404))
+				Expect(response.Headers).To(BeNil())
 			})
 
 			It("Default error handling (insufficient storage)", func() {
@@ -437,11 +432,10 @@ var _ = Describe("FileConnector", func() {
 					Status: status.NewInsufficientStorage(ctx, nil, "file too big"),
 				}, nil)
 
-				newLockId, err := fc.Lock(ctx, "abcdef123", "112233")
-				Expect(err).To(HaveOccurred())
-				conErr := err.(*connector.ConnectorError)
-				Expect(conErr.HttpCodeOut).To(Equal(500))
-				Expect(newLockId).To(Equal(""))
+				response, err := fc.Lock(ctx, "abcdef123", "112233")
+				Expect(err).To(Succeed())
+				Expect(response.Status).To(Equal(500))
+				Expect(response.Headers).To(BeNil())
 			})
 		})
 	})
@@ -449,19 +443,18 @@ var _ = Describe("FileConnector", func() {
 	Describe("RefreshLock", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			newLockId, err := fc.RefreshLock(ctx, "newLock")
+			response, err := fc.RefreshLock(ctx, "newLock")
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Empty lockId", func() {
 			ctx := middleware.WopiContextToCtx(context.Background(), wopiCtx)
 
-			newLockId, err := fc.RefreshLock(ctx, "")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(400))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.RefreshLock(ctx, "")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(400))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Refresh lock fails", func() {
@@ -472,10 +465,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewConflict(ctx, nil, "lock mismatch"),
 			}, targetErr)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
+			response, err := fc.RefreshLock(ctx, "abcdef123")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Refresh lock success", func() {
@@ -485,9 +478,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
+			response, err := fc.RefreshLock(ctx, "abcdef123")
 			Expect(err).To(Succeed())
-			Expect(newLockId).To(Equal(""))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Refresh lock file not found", func() {
@@ -497,11 +491,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewNotFound(ctx, "file not found"),
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(404))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.RefreshLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(404))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Refresh lock mismatch and get lock fails", func() {
@@ -516,10 +509,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewConflict(ctx, nil, "lock mismatch"),
 			}, targetErr)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
+			response, err := fc.RefreshLock(ctx, "abcdef123")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Refresh lock mismatch and get lock status not ok", func() {
@@ -533,11 +526,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "lock mismatch"),
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.RefreshLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Refresh lock mismatch and no lock", func() {
@@ -551,11 +543,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.RefreshLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal(""))
 		})
 
 		It("Refresh lock mismatch", func() {
@@ -573,11 +564,10 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal("zzz999"))
+			response, err := fc.RefreshLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 		})
 
 		It("Default error handling (insufficient storage)", func() {
@@ -587,30 +577,28 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInsufficientStorage(ctx, nil, "file too big"),
 			}, nil)
 
-			newLockId, err := fc.RefreshLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.RefreshLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 	})
 
 	Describe("Unlock", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			newLockId, err := fc.UnLock(ctx, "newLock")
+			response, err := fc.UnLock(ctx, "newLock")
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Empty lockId", func() {
 			ctx := middleware.WopiContextToCtx(context.Background(), wopiCtx)
 
-			newLockId, err := fc.UnLock(ctx, "")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(400))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.UnLock(ctx, "")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(400))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Unlock fails", func() {
@@ -621,10 +609,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
+			response, err := fc.UnLock(ctx, "abcdef123")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Unlock success", func() {
@@ -634,9 +622,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
+			response, err := fc.UnLock(ctx, "abcdef123")
 			Expect(err).To(Succeed())
-			Expect(newLockId).To(Equal(""))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Unlock file isn't locked", func() {
@@ -646,11 +635,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewConflict(ctx, nil, "lock mismatch"),
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.UnLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal(""))
 		})
 
 		It("Unlock mismatch get lock fails", func() {
@@ -665,10 +653,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
+			response, err := fc.UnLock(ctx, "abcdef123")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Unlock mismatch get lock status not ok", func() {
@@ -682,11 +670,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.UnLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Unlock mismatch get lock doesn't return lock", func() {
@@ -700,11 +687,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.UnLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal(""))
 		})
 
 		It("Unlock mismatch", func() {
@@ -722,11 +708,10 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(newLockId).To(Equal("zzz999"))
+			response, err := fc.UnLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 		})
 
 		It("Default error handling (insufficient storage)", func() {
@@ -736,11 +721,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInsufficientStorage(ctx, nil, "file too big"),
 			}, nil)
 
-			newLockId, err := fc.UnLock(ctx, "abcdef123")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newLockId).To(Equal(""))
+			response, err := fc.UnLock(ctx, "abcdef123")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 	})
 
@@ -777,10 +761,10 @@ var _ = Describe("FileConnector", func() {
 
 			stream := strings.NewReader("This is the content of a file")
 			response, err := fc.PutRelativeFileSuggested(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(response).To(BeNil())
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("PutRelativeFileSuggested success", func() {
@@ -807,7 +791,7 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", nil)
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			stat2ParamMatcher := mock.MatchedBy(func(statReq *providerv1beta1.StatRequest) bool {
 				if statReq.Ref.ResourceId.StorageId == "storageid" &&
@@ -832,8 +816,11 @@ var _ = Describe("FileConnector", func() {
 
 			response, err := fc.PutRelativeFileSuggested(ctx, ccs, stream, int64(stream.Len()), "newDocument.docx")
 			Expect(err).To(Succeed())
-			Expect(response.Name).To(Equal("newDocument.docx"))
-			Expect(response.Url).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(Equal("newDocument.docx"))
+			Expect(rBody["Url"]).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
 		})
 
 		It("PutRelativeFileSuggested success only extension", func() {
@@ -860,7 +847,7 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", nil)
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			stat2ParamMatcher := mock.MatchedBy(func(statReq *providerv1beta1.StatRequest) bool {
 				if statReq.Ref.ResourceId.StorageId == "storageid" &&
@@ -885,8 +872,11 @@ var _ = Describe("FileConnector", func() {
 
 			response, err := fc.PutRelativeFileSuggested(ctx, ccs, stream, int64(stream.Len()), ".pdf")
 			Expect(err).To(Succeed())
-			Expect(response.Name).To(Equal("file.pdf"))
-			Expect(response.Url).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(Equal("file.pdf"))
+			Expect(rBody["Url"]).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
 		})
 
 		It("PutRelativeFileSuggested success conflict", func() {
@@ -916,9 +906,10 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			// first call will fail with conflict, second call succeeds
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", connector.NewConnectorError(409, "file conflict")).Once()
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", nil).Once()
+			// first call will fail with conflict, second call succeeds.
+			// we're only interested on whether the file is locked or not, the actual lockID is irrelevant
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 409}, nil).Once()
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil).Once()
 
 			newFilePath := new(string)
 			stat2ParamMatcher := mock.MatchedBy(func(statReq *providerv1beta1.StatRequest) bool {
@@ -950,8 +941,11 @@ var _ = Describe("FileConnector", func() {
 
 			response, err := fc.PutRelativeFileSuggested(ctx, ccs, stream, int64(stream.Len()), ".pdf")
 			Expect(err).To(Succeed())
-			Expect(response.Name).To(MatchRegexp(`[a-zA-Z0-9_-] file\.pdf`))
-			Expect(response.Url).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(MatchRegexp(`[a-zA-Z0-9_-] file\.pdf`))
+			Expect(rBody["Url"]).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
 		})
 
 		It("PutRelativeFileSuggested put file fails", func() {
@@ -977,11 +971,13 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", connector.NewConnectorError(500, "something bad happened"))
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 500}, nil)
 
 			response, err := fc.PutRelativeFileSuggested(ctx, ccs, stream, int64(stream.Len()), ".pdf")
-			Expect(err).To(HaveOccurred())
-			Expect(response).To(BeNil())
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 	})
 
@@ -989,10 +985,9 @@ var _ = Describe("FileConnector", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
 			stream := strings.NewReader("This is the content of a file")
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
 			Expect(err).To(HaveOccurred())
 			Expect(response).To(BeNil())
-			Expect(headers).To(BeNil())
 		})
 
 		It("Stat fails", func() {
@@ -1004,11 +999,10 @@ var _ = Describe("FileConnector", func() {
 			}, targetErr)
 
 			stream := strings.NewReader("This is the content of a file")
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
 			Expect(response).To(BeNil())
-			Expect(headers).To(BeNil())
 		})
 
 		It("Stat fails status not ok", func() {
@@ -1019,12 +1013,11 @@ var _ = Describe("FileConnector", func() {
 			}, nil)
 
 			stream := strings.NewReader("This is the content of a file")
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(response).To(BeNil())
-			Expect(headers).To(BeNil())
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newFile.txt")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("PutRelativeFileRelative success", func() {
@@ -1050,7 +1043,7 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", nil)
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			stat2ParamMatcher := mock.MatchedBy(func(statReq *providerv1beta1.StatRequest) bool {
 				if statReq.Ref.ResourceId.StorageId == "storageid" &&
@@ -1073,11 +1066,13 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newDocument.docx")
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "newDocument.docx")
 			Expect(err).To(Succeed())
-			Expect(response.Name).To(Equal("newDocument.docx"))
-			Expect(response.Url).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
-			Expect(headers).To(BeNil())
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(Equal("newDocument.docx"))
+			Expect(rBody["Url"]).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
 		})
 
 		It("PutRelativeFileRelative conflict", func() {
@@ -1103,7 +1098,7 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("zzz999", connector.NewConnectorError(409, "file conflict"))
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz999"}}, nil)
 
 			stat2ParamMatcher := mock.MatchedBy(func(statReq *providerv1beta1.StatRequest) bool {
 				if statReq.Ref.ResourceId.StorageId == "storageid" &&
@@ -1130,12 +1125,14 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "convFile.pdf")
-			Expect(err).To(HaveOccurred())
-			Expect(response.Name).To(Equal("convFile.pdf"))
-			Expect(response.Url).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
-			Expect(headers.ValidTarget).To(MatchRegexp(`[a-zA-Z0-9_-] convFile\.pdf`))
-			Expect(headers.LockID).To(Equal("zzz999"))
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "convFile.pdf")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
+			Expect(response.Headers[connector.HeaderWopiValidRT]).To(MatchRegexp(`[a-zA-Z0-9_-] convFile\.pdf`))
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(Equal("convFile.pdf"))
+			Expect(rBody["Url"]).To(HavePrefix("https://ocis.server.prv/wopi/files/")) // skip checking the actual reference
 		})
 
 		It("PutRelativeFileRelative put file fails", func() {
@@ -1161,21 +1158,22 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return("", connector.NewConnectorError(500, "something bad happened"))
+			ccs.On("PutFile", mock.Anything, stream, int64(stream.Len()), "").Times(1).Return(&connector.ConnectorResponse{Status: 500}, nil)
 
-			response, headers, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "convFile.pdf")
-			Expect(err).To(HaveOccurred())
-			Expect(response).To(BeNil())
-			Expect(headers).To(BeNil())
+			response, err := fc.PutRelativeFileRelative(ctx, ccs, stream, int64(stream.Len()), "convFile.pdf")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 	})
 
 	Describe("DeleteFile", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			newLockId, err := fc.DeleteFile(ctx, "lock")
+			response, err := fc.DeleteFile(ctx, "lock")
 			Expect(err).To(HaveOccurred())
-			Expect(newLockId).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Delete fails", func() {
@@ -1190,10 +1188,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
+			response, err := fc.DeleteFile(ctx, "newlock")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(lockID).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Delete fails status not ok, get lock fails", func() {
@@ -1208,10 +1206,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
+			response, err := fc.DeleteFile(ctx, "newlock")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(lockID).To(Equal(""))
+			Expect(response).To(BeNil())
 		})
 
 		It("Delete fails file missing", func() {
@@ -1226,11 +1224,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(404))
-			Expect(lockID).To(Equal(""))
+			response, err := fc.DeleteFile(ctx, "newlock")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(404))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Delete fails status not ok, get lock not ok", func() {
@@ -1244,11 +1241,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, nil)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(lockID).To(Equal(""))
+			response, err := fc.DeleteFile(ctx, "newlock")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Delete fails, file locked", func() {
@@ -1266,11 +1262,10 @@ var _ = Describe("FileConnector", func() {
 				},
 			}, nil)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(lockID).To(Equal("zzz999"))
+			response, err := fc.DeleteFile(ctx, "newlock")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
 		})
 
 		It("Delete fails, file not locked", func() {
@@ -1284,11 +1279,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(lockID).To(Equal(""))
+			response, err := fc.DeleteFile(ctx, "newlock")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
 		})
 
 		It("Delete success", func() {
@@ -1298,18 +1292,18 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil)
 
-			lockID, err := fc.DeleteFile(ctx, "newlock")
+			response, err := fc.DeleteFile(ctx, "newlock")
 			Expect(err).To(Succeed())
-			Expect(lockID).To(Equal(""))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
 		})
 	})
 
 	Describe("RenameFile", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
 			Expect(err).To(HaveOccurred())
-			Expect(lockID).To(Equal(""))
 			Expect(response).To(BeNil())
 		})
 
@@ -1321,10 +1315,9 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(lockID).To(Equal(""))
 			Expect(response).To(BeNil())
 		})
 
@@ -1335,12 +1328,11 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, nil)
 
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(lockID).To(Equal(""))
-			Expect(response).To(BeNil())
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("Rename failed", func() {
@@ -1361,10 +1353,9 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(lockID).To(Equal(""))
 			Expect(response).To(BeNil())
 		})
 
@@ -1385,12 +1376,11 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, nil)
 
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(lockID).To(Equal(""))
-			Expect(response).To(BeNil())
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Headers).To(BeNil())
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("Rename conflict", func() {
@@ -1410,12 +1400,11 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewLocked(ctx, "lock mismatch"),
 			}, nil)
 
-			response, lockID, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(409))
-			Expect(lockID).To(Equal("zzz999"))
-			Expect(response).To(BeNil())
+			response, err := fc.RenameFile(ctx, "lockid", "newFile.doc")
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(409))
+			Expect(response.Headers[connector.HeaderWopiLock]).To(Equal("zzz999"))
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("Rename already exists", func() {
@@ -1454,10 +1443,12 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil).Once()
 
-			response, lockID, err := fc.RenameFile(ctx, "zzz999", "newFile.doc")
+			response, err := fc.RenameFile(ctx, "zzz999", "newFile.doc")
 			Expect(err).To(Succeed())
-			Expect(lockID).To(Equal(""))
-			Expect(response.Name).To(MatchRegexp(`^[a-zA-Z0-9_-]+ newFile$`))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(MatchRegexp(`^[a-zA-Z0-9_-]+ newFile$`))
 		})
 
 		It("Success", func() {
@@ -1484,19 +1475,21 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewOK(ctx),
 			}, nil).Once()
 
-			response, lockID, err := fc.RenameFile(ctx, "zzz999", "newFile.doc")
+			response, err := fc.RenameFile(ctx, "zzz999", "newFile.doc")
 			Expect(err).To(Succeed())
-			Expect(lockID).To(Equal(""))
-			Expect(response.Name).To(Equal("newFile"))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Headers).To(BeNil())
+			rBody := response.Body.(map[string]interface{})
+			Expect(rBody["Name"]).To(Equal("newFile"))
 		})
 	})
 
 	Describe("CheckFileInfo", func() {
 		It("No valid context", func() {
 			ctx := context.Background()
-			newFileInfo, err := fc.CheckFileInfo(ctx)
+			response, err := fc.CheckFileInfo(ctx)
 			Expect(err).To(HaveOccurred())
-			Expect(newFileInfo).To(BeNil())
+			Expect(response).To(BeNil())
 		})
 
 		It("Stat fails", func() {
@@ -1507,10 +1500,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, targetErr)
 
-			newFileInfo, err := fc.CheckFileInfo(ctx)
+			response, err := fc.CheckFileInfo(ctx)
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(targetErr))
-			Expect(newFileInfo).To(BeNil())
+			Expect(response).To(BeNil())
 		})
 
 		It("Stat fails status not ok", func() {
@@ -1520,11 +1513,10 @@ var _ = Describe("FileConnector", func() {
 				Status: status.NewInternal(ctx, "something failed"),
 			}, nil)
 
-			newFileInfo, err := fc.CheckFileInfo(ctx)
-			Expect(err).To(HaveOccurred())
-			conErr := err.(*connector.ConnectorError)
-			Expect(conErr.HttpCodeOut).To(Equal(500))
-			Expect(newFileInfo).To(BeNil())
+			response, err := fc.CheckFileInfo(ctx)
+			Expect(err).To(Succeed())
+			Expect(response.Status).To(Equal(500))
+			Expect(response.Body).To(BeNil())
 		})
 
 		It("Stat success", func() {
@@ -1568,9 +1560,10 @@ var _ = Describe("FileConnector", func() {
 				UserFriendlyName:           "Pet Shaft",
 			}
 
-			newFileInfo, err := fc.CheckFileInfo(ctx)
+			response, err := fc.CheckFileInfo(ctx)
 			Expect(err).To(Succeed())
-			Expect(newFileInfo.(*fileinfo.Microsoft)).To(Equal(expectedFileInfo))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Body.(*fileinfo.Microsoft)).To(Equal(expectedFileInfo))
 		})
 
 		It("Stat success guests", func() {
@@ -1626,18 +1619,19 @@ var _ = Describe("FileConnector", func() {
 				PostMessageOrigin:       "https://ocis.example.prv",
 			}
 
-			newFileInfo, err := fc.CheckFileInfo(ctx)
+			response, err := fc.CheckFileInfo(ctx)
 
 			// UserID and UserFriendlyName have random Ids generated which are impossible to guess
 			// Check both separately
-			Expect(newFileInfo.(*fileinfo.Collabora).UserID).To(HavePrefix(hex.EncodeToString([]byte("guest-"))))
-			Expect(newFileInfo.(*fileinfo.Collabora).UserFriendlyName).To(HavePrefix("Guest "))
+			Expect(response.Body.(*fileinfo.Collabora).UserID).To(HavePrefix(hex.EncodeToString([]byte("guest-"))))
+			Expect(response.Body.(*fileinfo.Collabora).UserFriendlyName).To(HavePrefix("Guest "))
 			// overwrite UserID and UserFriendlyName here for easier matching
-			newFileInfo.(*fileinfo.Collabora).UserID = "guest-zzz000"
-			newFileInfo.(*fileinfo.Collabora).UserFriendlyName = "guest zzz000"
+			response.Body.(*fileinfo.Collabora).UserID = "guest-zzz000"
+			response.Body.(*fileinfo.Collabora).UserFriendlyName = "guest zzz000"
 
 			Expect(err).To(Succeed())
-			Expect(newFileInfo.(*fileinfo.Collabora)).To(Equal(expectedFileInfo))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Body.(*fileinfo.Collabora)).To(Equal(expectedFileInfo))
 		})
 
 		It("Stat success authenticated user", func() {
@@ -1685,10 +1679,11 @@ var _ = Describe("FileConnector", func() {
 				PostMessageOrigin:       "https://ocis.example.prv",
 			}
 
-			newFileInfo, err := fc.CheckFileInfo(ctx)
+			response, err := fc.CheckFileInfo(ctx)
 
 			Expect(err).To(Succeed())
-			Expect(newFileInfo.(*fileinfo.Collabora)).To(Equal(expectedFileInfo))
+			Expect(response.Status).To(Equal(200))
+			Expect(response.Body.(*fileinfo.Collabora)).To(Equal(expectedFileInfo))
 		})
 	})
 })
diff --git a/services/collaboration/pkg/connector/httpadapter_test.go b/services/collaboration/pkg/connector/httpadapter_test.go
index 390740e51..59d9f6fd5 100644
--- a/services/collaboration/pkg/connector/httpadapter_test.go
+++ b/services/collaboration/pkg/connector/httpadapter_test.go
@@ -47,7 +47,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("GetLock", mock.Anything).Times(1).Return("", errors.New("Something happened"))
+			fc.On("GetLock", mock.Anything).Times(1).Return(nil, errors.New("Something happened"))
 
 			httpAdapter.GetLock(w, req)
 			resp := w.Result()
@@ -60,7 +60,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("GetLock", mock.Anything).Times(1).Return("", connector.NewConnectorError(404, "Couldn't get the file"))
+			fc.On("GetLock", mock.Anything).Times(1).Return(&connector.ConnectorResponse{Status: 404}, nil)
 
 			httpAdapter.GetLock(w, req)
 			resp := w.Result()
@@ -73,7 +73,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("GetLock", mock.Anything).Times(1).Return("zzz111", nil)
+			fc.On("GetLock", mock.Anything).Times(1).Return(&connector.ConnectorResponse{Status: 200, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 			httpAdapter.GetLock(w, req)
 			resp := w.Result()
@@ -87,7 +87,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("GetLock", mock.Anything).Times(1).Return("", nil)
+			fc.On("GetLock", mock.Anything).Times(1).Return(&connector.ConnectorResponse{Status: 200, Headers: map[string]string{connector.HeaderWopiLock: ""}}, nil)
 
 			httpAdapter.GetLock(w, req)
 			resp := w.Result()
@@ -105,7 +105,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return("", errors.New("Something happened"))
+				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return(nil, errors.New("Something happened"))
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -119,7 +119,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "", "").Times(1).Return("", connector.NewConnectorError(400, "No lockId"))
+				fc.On("Lock", mock.Anything, "", "").Times(1).Return(&connector.ConnectorResponse{Status: 400}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -133,7 +133,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return("zzz111", connector.NewConnectorError(409, "Lock conflict"))
+				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -148,7 +148,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return("", nil)
+				fc.On("Lock", mock.Anything, "abc123", "").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -165,7 +165,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return("", errors.New("Something happened"))
+				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return(nil, errors.New("Something happened"))
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -180,7 +180,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "", "").Times(1).Return("", connector.NewConnectorError(400, "No lockId"))
+				fc.On("Lock", mock.Anything, "", "").Times(1).Return(&connector.ConnectorResponse{Status: 400}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -195,7 +195,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return("zzz111", connector.NewConnectorError(409, "Lock conflict"))
+				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -211,7 +211,7 @@ var _ = Describe("HttpAdapter", func() {
 
 				w := httptest.NewRecorder()
 
-				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return("", nil)
+				fc.On("Lock", mock.Anything, "abc123", "qwerty").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 				httpAdapter.Lock(w, req)
 				resp := w.Result()
@@ -228,7 +228,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return("", errors.New("Something happened"))
+			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return(nil, errors.New("Something happened"))
 
 			httpAdapter.RefreshLock(w, req)
 			resp := w.Result()
@@ -242,7 +242,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("RefreshLock", mock.Anything, "").Times(1).Return("", connector.NewConnectorError(400, "No lockId"))
+			fc.On("RefreshLock", mock.Anything, "").Times(1).Return(&connector.ConnectorResponse{Status: 400}, nil)
 
 			httpAdapter.RefreshLock(w, req)
 			resp := w.Result()
@@ -256,7 +256,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return("zzz111", connector.NewConnectorError(409, "Lock conflict"))
+			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 			httpAdapter.RefreshLock(w, req)
 			resp := w.Result()
@@ -271,7 +271,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return("", nil)
+			fc.On("RefreshLock", mock.Anything, "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			httpAdapter.RefreshLock(w, req)
 			resp := w.Result()
@@ -287,7 +287,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return("", errors.New("Something happened"))
+			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return(nil, errors.New("Something happened"))
 
 			httpAdapter.UnLock(w, req)
 			resp := w.Result()
@@ -301,7 +301,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("UnLock", mock.Anything, "").Times(1).Return("", connector.NewConnectorError(400, "No lockId"))
+			fc.On("UnLock", mock.Anything, "").Times(1).Return(&connector.ConnectorResponse{Status: 400}, nil)
 
 			httpAdapter.UnLock(w, req)
 			resp := w.Result()
@@ -315,7 +315,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return("zzz111", connector.NewConnectorError(409, "Lock conflict"))
+			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 			httpAdapter.UnLock(w, req)
 			resp := w.Result()
@@ -330,7 +330,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return("", nil)
+			fc.On("UnLock", mock.Anything, "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			httpAdapter.UnLock(w, req)
 			resp := w.Result()
@@ -344,7 +344,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(&fileinfo.Microsoft{}, errors.New("Something happened"))
+			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(nil, errors.New("Something happened"))
 
 			httpAdapter.CheckFileInfo(w, req)
 			resp := w.Result()
@@ -358,7 +358,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(&fileinfo.Microsoft{}, connector.NewConnectorError(404, "Not found"))
+			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(&connector.ConnectorResponse{Status: 404}, nil)
 
 			httpAdapter.CheckFileInfo(w, req)
 			resp := w.Result()
@@ -375,7 +375,7 @@ var _ = Describe("HttpAdapter", func() {
 				Size:              123456789,
 				BreadcrumbDocName: "testy.docx",
 			}
-			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(finfo, nil)
+			fc.On("CheckFileInfo", mock.Anything).Times(1).Return(&connector.ConnectorResponse{Status: 200, Body: finfo}, nil)
 
 			httpAdapter.CheckFileInfo(w, req)
 			resp := w.Result()
@@ -444,7 +444,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return("", errors.New("Something happened"))
+			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return(nil, errors.New("Something happened"))
 
 			httpAdapter.PutFile(w, req)
 			resp := w.Result()
@@ -458,7 +458,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return("zzz111", connector.NewConnectorError(409, "Lock conflict"))
+			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 409, Headers: map[string]string{connector.HeaderWopiLock: "zzz111"}}, nil)
 
 			httpAdapter.PutFile(w, req)
 			resp := w.Result()
@@ -473,7 +473,7 @@ var _ = Describe("HttpAdapter", func() {
 
 			w := httptest.NewRecorder()
 
-			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return("", nil)
+			cc.On("PutFile", mock.Anything, mock.Anything, int64(len(contentBody)), "abc123").Times(1).Return(&connector.ConnectorResponse{Status: 200}, nil)
 
 			httpAdapter.PutFile(w, req)
 			resp := w.Result()