Consolidate attachment URL construction.

sync/internal_api/attachments/attachment_uploader_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sync/internal_api/public/attachments/attachment_uploader_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
@@ skipping 15 matching lines @@
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAttachmentData[] = "some data";
 const char kAccountId[] = "some-account-id";
 const char kAccessToken[] = "some-access-token";
 const char kAuthorization[] = "Authorization";
+const char kAttachments[] = "/attachments/";
 
 }  // namespace
 
 namespace syncer {
 
 using net::test_server::BasicHttpResponse;
 using net::test_server::HttpRequest;
 using net::test_server::HttpResponse;
 
 class RequestHandler;
@@ skipping 211 matching lines @@
   request_handler_.reset(new RequestHandler(message_loop_.message_loop_proxy(),
                                             weak_ptr_factory_.GetWeakPtr()));
   url_request_context_getter_ =
       new net::TestURLRequestContextGetter(message_loop_.message_loop_proxy());
 
   ASSERT_TRUE(server_.InitializeAndWaitUntilReady());
   server_.RegisterRequestHandler(
       base::Bind(&RequestHandler::HandleRequest,
                  base::Unretained(request_handler_.get())));
 
-  std::string url_prefix(
-      base::StringPrintf("http://localhost:%d/uploads/", server_.port()));
+  GURL url(base::StringPrintf("http://localhost:%d/", server_.port()));
 
   token_service_.reset(new MockOAuth2TokenService);
   scoped_ptr<OAuth2TokenServiceRequest::TokenServiceProvider>
       token_service_provider(new TokenServiceProvider(token_service_.get()));
 
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
-  uploader().reset(new AttachmentUploaderImpl(url_prefix,
+  uploader().reset(new AttachmentUploaderImpl(url,
                                               url_request_context_getter_,
                                               kAccountId,
                                               scopes,
                                               token_service_provider.Pass()));
 
   upload_callback_ = base::Bind(&AttachmentUploaderImplTest::UploadDone,
                                 base::Unretained(this));
 }
 
 void AttachmentUploaderImplTest::TearDown() {
@@ skipping 83 matching lines @@
 void RequestHandler::SetStatusCode(const net::HttpStatusCode& status_code) {
   base::AutoLock lock(mutex_);
   status_code_ = status_code;
 }
 
 net::HttpStatusCode RequestHandler::GetStatusCode() const {
   base::AutoLock lock(mutex_);
   return status_code_;
 }
 
+TEST_F(AttachmentUploaderImplTest, GetURLForAttachmentId_NoPath) {
+  AttachmentId id = AttachmentId::Create();
+  std::string unique_id = id.GetProto().unique_id();
+  GURL sync_service_url("https://example.com");
+  EXPECT_EQ("https://example.com/attachments/" + unique_id,
+            AttachmentUploaderImpl::GetURLForAttachmentId(sync_service_url, id)
+                .spec());
+}
+
+TEST_F(AttachmentUploaderImplTest, GetURLForAttachmentId_JustSlash) {
+  AttachmentId id = AttachmentId::Create();
+  std::string unique_id = id.GetProto().unique_id();
+  GURL sync_service_url("https://example.com/");
+  EXPECT_EQ("https://example.com/attachments/" + unique_id,
+            AttachmentUploaderImpl::GetURLForAttachmentId(sync_service_url, id)
+                .spec());
+}
+
+TEST_F(AttachmentUploaderImplTest, GetURLForAttachmentId_Path) {
+  AttachmentId id = AttachmentId::Create();
+  std::string unique_id = id.GetProto().unique_id();
+  GURL sync_service_url("https://example.com/service");
+  EXPECT_EQ("https://example.com/service/attachments/" + unique_id,
+            AttachmentUploaderImpl::GetURLForAttachmentId(sync_service_url, id)
+                .spec());
+}
+
+TEST_F(AttachmentUploaderImplTest, GetURLForAttachmentId_PathAndSlash) {
+  AttachmentId id = AttachmentId::Create();
+  std::string unique_id = id.GetProto().unique_id();
+  GURL sync_service_url("https://example.com/service/");
+  EXPECT_EQ("https://example.com/service/attachments/" + unique_id,
+            AttachmentUploaderImpl::GetURLForAttachmentId(sync_service_url, id)
+                .spec());
+}
+
 // Verify the "happy case" of uploading an attachment.
 //
 // Token is requested, token is returned, HTTP request is made, attachment is
 // received by server.
 TEST_F(AttachmentUploaderImplTest, UploadAttachment_HappyCase) {
   token_service().AddAccount(kAccountId);
   request_handler().SetStatusCode(net::HTTP_OK);
 
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(some_data);
   uploader()->UploadAttachment(attachment, upload_callback());
 
   // Run until the done callback is invoked.
   RunAndWaitFor(1);
 
   // See that the done callback was invoked with the right arguments.
   ASSERT_EQ(1U, upload_results().size());
   EXPECT_EQ(AttachmentUploader::UPLOAD_SUCCESS, upload_results()[0]);
   ASSERT_EQ(1U, updated_attachment_ids().size());
   EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
-  std::string expected_relative_url("/uploads/" +
+  std::string expected_relative_url(kAttachments +
                                     attachment.GetId().GetProto().unique_id());
   EXPECT_EQ(expected_relative_url, http_request.relative_url);
   EXPECT_TRUE(http_request.has_content);
   EXPECT_EQ(kAttachmentData, http_request.content);
   const std::string header_name(kAuthorization);
   const std::string header_value(std::string("Bearer ") + kAccessToken);
   EXPECT_THAT(http_request.headers,
               testing::Contains(testing::Pair(header_name, header_value)));
 
   // TODO(maniscalco): Once AttachmentUploaderImpl is capable of updating the
@@ skipping 82 matching lines @@
   // See that the done callback was invoked.
   ASSERT_EQ(1U, upload_results().size());
   EXPECT_EQ(AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR, upload_results()[0]);
   ASSERT_EQ(1U, updated_attachment_ids().size());
   EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
-  std::string expected_relative_url("/uploads/" +
+  std::string expected_relative_url(kAttachments +
                                     attachment.GetId().GetProto().unique_id());
   EXPECT_EQ(expected_relative_url, http_request.relative_url);
   EXPECT_TRUE(http_request.has_content);
   EXPECT_EQ(kAttachmentData, http_request.content);
   std::string expected_header(kAuthorization);
   const std::string header_name(kAuthorization);
   const std::string header_value(std::string("Bearer ") + kAccessToken);
   EXPECT_THAT(http_request.headers,
               testing::Contains(testing::Pair(header_name, header_value)));
 
@@ skipping 17 matching lines @@
   // See that the done callback was invoked.
   ASSERT_EQ(1U, upload_results().size());
   EXPECT_EQ(AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR, upload_results()[0]);
   ASSERT_EQ(1U, updated_attachment_ids().size());
   EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
-  std::string expected_relative_url("/uploads/" +
+  std::string expected_relative_url(kAttachments +
                                     attachment.GetId().GetProto().unique_id());
   EXPECT_EQ(expected_relative_url, http_request.relative_url);
   EXPECT_TRUE(http_request.has_content);
   EXPECT_EQ(kAttachmentData, http_request.content);
   std::string expected_header(kAuthorization);
   const std::string header_name(kAuthorization);
   const std::string header_value(std::string("Bearer ") + kAccessToken);
   EXPECT_THAT(http_request.headers,
               testing::Contains(testing::Pair(header_name, header_value)));
 
   // See that we invalidated the token.
   ASSERT_EQ(1, token_service().num_invalidate_token());
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer