1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "google_apis/drive/test_util.h"
6
7 #include "base/files/file_util.h"
8 #include "base/json/json_file_value_serializer.h"
9 #include "base/json/json_reader.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/path_service.h"
12 #include "base/rand_util.h"
13 #include "base/run_loop.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/string_split.h"
16 #include "base/strings/string_util.h"
17 #include "base/strings/stringprintf.h"
18 #include "google_apis/drive/drive_api_parser.h"
19 #include "google_apis/drive/gdata_wapi_parser.h"
20 #include "google_apis/drive/gdata_wapi_requests.h"
21 #include "net/test/embedded_test_server/http_request.h"
22 #include "net/test/embedded_test_server/http_response.h"
23 #include "url/gurl.h"
24
25 namespace google_apis {
26 namespace test_util {
27
RemovePrefix(const std::string & input,const std::string & prefix,std::string * output)28 bool RemovePrefix(const std::string& input,
29 const std::string& prefix,
30 std::string* output) {
31 if (!StartsWithASCII(input, prefix, true /* case sensitive */))
32 return false;
33
34 *output = input.substr(prefix.size());
35 return true;
36 }
37
GetTestFilePath(const std::string & relative_path)38 base::FilePath GetTestFilePath(const std::string& relative_path) {
39 base::FilePath path;
40 if (!PathService::Get(base::DIR_SOURCE_ROOT, &path))
41 return base::FilePath();
42 path = path.AppendASCII("chrome")
43 .AppendASCII("test")
44 .AppendASCII("data")
45 .Append(base::FilePath::FromUTF8Unsafe(relative_path));
46 return path;
47 }
48
GetBaseUrlForTesting(int port)49 GURL GetBaseUrlForTesting(int port) {
50 return GURL(base::StringPrintf("http://127.0.0.1:%d/", port));
51 }
52
RunAndQuit(base::RunLoop * run_loop,const base::Closure & closure)53 void RunAndQuit(base::RunLoop* run_loop, const base::Closure& closure) {
54 closure.Run();
55 run_loop->Quit();
56 }
57
WriteStringToFile(const base::FilePath & file_path,const std::string & content)58 bool WriteStringToFile(const base::FilePath& file_path,
59 const std::string& content) {
60 int result = base::WriteFile(
61 file_path, content.data(), static_cast<int>(content.size()));
62 return content.size() == static_cast<size_t>(result);
63 }
64
CreateFileOfSpecifiedSize(const base::FilePath & temp_dir,size_t size,base::FilePath * path,std::string * data)65 bool CreateFileOfSpecifiedSize(const base::FilePath& temp_dir,
66 size_t size,
67 base::FilePath* path,
68 std::string* data) {
69 if (!base::CreateTemporaryFileInDir(temp_dir, path))
70 return false;
71
72 if (size == 0) {
73 // Note: RandBytesAsString doesn't support generating an empty string.
74 data->clear();
75 return true;
76 }
77
78 *data = base::RandBytesAsString(size);
79 return WriteStringToFile(*path, *data);
80 }
81
LoadJSONFile(const std::string & relative_path)82 scoped_ptr<base::Value> LoadJSONFile(const std::string& relative_path) {
83 base::FilePath path = GetTestFilePath(relative_path);
84
85 std::string error;
86 JSONFileValueSerializer serializer(path);
87 scoped_ptr<base::Value> value(serializer.Deserialize(NULL, &error));
88 LOG_IF(WARNING, !value.get()) << "Failed to parse " << path.value()
89 << ": " << error;
90 return value.Pass();
91 }
92
93 // Returns a HttpResponse created from the given file path.
CreateHttpResponseFromFile(const base::FilePath & file_path)94 scoped_ptr<net::test_server::BasicHttpResponse> CreateHttpResponseFromFile(
95 const base::FilePath& file_path) {
96 std::string content;
97 if (!base::ReadFileToString(file_path, &content))
98 return scoped_ptr<net::test_server::BasicHttpResponse>();
99
100 std::string content_type = "text/plain";
101 if (EndsWith(file_path.AsUTF8Unsafe(), ".json", true /* case sensitive */))
102 content_type = "application/json";
103
104 scoped_ptr<net::test_server::BasicHttpResponse> http_response(
105 new net::test_server::BasicHttpResponse);
106 http_response->set_code(net::HTTP_OK);
107 http_response->set_content(content);
108 http_response->set_content_type(content_type);
109 return http_response.Pass();
110 }
111
HandleDownloadFileRequest(const GURL & base_url,net::test_server::HttpRequest * out_request,const net::test_server::HttpRequest & request)112 scoped_ptr<net::test_server::HttpResponse> HandleDownloadFileRequest(
113 const GURL& base_url,
114 net::test_server::HttpRequest* out_request,
115 const net::test_server::HttpRequest& request) {
116 *out_request = request;
117
118 GURL absolute_url = base_url.Resolve(request.relative_url);
119 std::string remaining_path;
120 if (!RemovePrefix(absolute_url.path(), "/files/", &remaining_path))
121 return scoped_ptr<net::test_server::HttpResponse>();
122 return CreateHttpResponseFromFile(
123 GetTestFilePath(remaining_path)).PassAs<net::test_server::HttpResponse>();
124 }
125
ParseContentRangeHeader(const std::string & value,int64 * start_position,int64 * end_position,int64 * length)126 bool ParseContentRangeHeader(const std::string& value,
127 int64* start_position,
128 int64* end_position,
129 int64* length) {
130 DCHECK(start_position);
131 DCHECK(end_position);
132 DCHECK(length);
133
134 std::string remaining;
135 if (!RemovePrefix(value, "bytes ", &remaining))
136 return false;
137
138 std::vector<std::string> parts;
139 base::SplitString(remaining, '/', &parts);
140 if (parts.size() != 2U)
141 return false;
142
143 const std::string range = parts[0];
144 if (!base::StringToInt64(parts[1], length))
145 return false;
146
147 parts.clear();
148 base::SplitString(range, '-', &parts);
149 if (parts.size() != 2U)
150 return false;
151
152 return (base::StringToInt64(parts[0], start_position) &&
153 base::StringToInt64(parts[1], end_position));
154 }
155
AppendProgressCallbackResult(std::vector<ProgressInfo> * progress_values,int64 progress,int64 total)156 void AppendProgressCallbackResult(std::vector<ProgressInfo>* progress_values,
157 int64 progress,
158 int64 total) {
159 progress_values->push_back(ProgressInfo(progress, total));
160 }
161
TestGetContentCallback()162 TestGetContentCallback::TestGetContentCallback()
163 : callback_(base::Bind(&TestGetContentCallback::OnGetContent,
164 base::Unretained(this))) {
165 }
166
~TestGetContentCallback()167 TestGetContentCallback::~TestGetContentCallback() {
168 }
169
GetConcatenatedData() const170 std::string TestGetContentCallback::GetConcatenatedData() const {
171 std::string result;
172 for (size_t i = 0; i < data_.size(); ++i) {
173 result += *data_[i];
174 }
175 return result;
176 }
177
OnGetContent(google_apis::GDataErrorCode error,scoped_ptr<std::string> data)178 void TestGetContentCallback::OnGetContent(google_apis::GDataErrorCode error,
179 scoped_ptr<std::string> data) {
180 data_.push_back(data.release());
181 }
182
183 } // namespace test_util
184 } // namespace google_apis
185