Debian Codegraph @

closure-library/closure/goog/testing/fs/filewriter_test.js

raw
1 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.testing.fs.FileWriterTest');
16 goog.setTestOnly('goog.testing.fs.FileWriterTest');
17
18 goog.require('goog.Promise');
19 goog.require('goog.array');
20 goog.require('goog.events');
21 goog.require('goog.fs.Error');
22 goog.require('goog.fs.FileSaver');
23 goog.require('goog.object');
24 goog.require('goog.testing.MockClock');
25 goog.require('goog.testing.events.EventObserver');
26 goog.require('goog.testing.fs.Blob');
27 goog.require('goog.testing.fs.FileSystem');
28 goog.require('goog.testing.jsunit');
29
30
31 var EventType = goog.fs.FileSaver.EventType;
32 var ReadyState = goog.fs.FileSaver.ReadyState;
33
34
35 /** @type {!goog.testing.fs.File} */
36 var file;
37
38
39 /** @type {!goog.testing.fs.FileWriter} */
40 var writer;
41
42
43 /** @type {!goog.testing.MockClock} */
44 var mockClock;
45
46
47 function setUp() {
48 // Temporarily install the MockClock to get predictable file modified times.
49 mockClock = new goog.testing.MockClock(true);
50 var fs = new goog.testing.fs.FileSystem();
51 var fileEntry = fs.getRoot().createDirectorySync('foo').createFileSync('bar');
52 mockClock.uninstall();
53
54 file = fileEntry.fileSync();
55 file.setDataInternal('');
56
57 return fileEntry.createWriter().then(function(fileWriter) {
58 writer = fileWriter;
59 });
60 }
61
62
63 function tearDown() {
64 goog.dispose(writer);
65 }
66
67
68 function testWrite() {
69 var observer = createObserver(writer);
70
71 mockClock.install();
72 assertEquals(ReadyState.INIT, writer.getReadyState());
73 assertPositionAndLength(0, 0, writer);
74 assertLastModified(0, file);
75
76 mockClock.tick(3);
77 var promise = writeString(writer, 'hello');
78 assertPositionAndLength(0, 0, writer);
79 assertEquals(ReadyState.WRITING, writer.getReadyState());
80
81 promise =
82 promise
83 .then(function() {
84 assertEquals('hello', file.toString());
85 assertPositionAndLength(5, 5, writer);
86 assertLastModified(3, file);
87
88 assertEquals(ReadyState.DONE, writer.getReadyState());
89 assertArrayEquals(
90 [EventType.WRITE_START, EventType.WRITE, EventType.WRITE_END],
91 goog.array.map(
92 observer.getEvents(), function(e) { return e.type; }));
93
94 var promise = writeString(writer, ' world');
95 assertEquals(ReadyState.WRITING, writer.getReadyState());
96 mockClock.tick();
97 return promise;
98 })
99 .then(function() {
100 assertEquals('hello world', file.toString());
101 assertPositionAndLength(11, 11, writer);
102 assertLastModified(4, file);
103
104 assertEquals(ReadyState.DONE, writer.getReadyState());
105 assertArrayEquals(
106 [
107 EventType.WRITE_START, EventType.WRITE, EventType.WRITE_END,
108 EventType.WRITE_START, EventType.WRITE, EventType.WRITE_END
109 ],
110 goog.array.map(
111 observer.getEvents(), function(e) { return e.type; }));
112
113 })
114 .thenAlways(function() { mockClock.uninstall(); });
115
116 mockClock.tick();
117 return promise;
118 }
119
120
121 function testSeek() {
122 mockClock.install();
123 mockClock.tick(17);
124 assertLastModified(0, file);
125
126 var promise = writeString(writer, 'hello world')
127 .then(function() {
128 assertPositionAndLength(11, 11, writer);
129 assertLastModified(17, file);
130
131 writer.seek(6);
132 assertPositionAndLength(6, 11, writer);
133
134 var promise = writeString(writer, 'universe');
135 mockClock.tick();
136 return promise;
137 })
138 .then(function() {
139 assertEquals('hello universe', file.toString());
140 assertPositionAndLength(14, 14, writer);
141
142 writer.seek(500);
143 assertPositionAndLength(14, 14, writer);
144
145 var promise = writeString(writer, '!');
146 mockClock.tick();
147 return promise;
148 })
149 .then(function() {
150 assertEquals('hello universe!', file.toString());
151 assertPositionAndLength(15, 15, writer);
152
153 writer.seek(-9);
154 assertPositionAndLength(6, 15, writer);
155
156 var promise = writeString(writer, 'foo');
157 mockClock.tick();
158 return promise;
159 })
160 .then(function() {
161 assertEquals('hello fooverse!', file.toString());
162 assertPositionAndLength(9, 15, writer);
163
164 writer.seek(-500);
165 assertPositionAndLength(0, 15, writer);
166
167 var promise = writeString(writer, 'bye-o');
168 mockClock.tick();
169 return promise;
170 })
171 .then(function() {
172 assertEquals('bye-o fooverse!', file.toString());
173 assertPositionAndLength(5, 15, writer);
174 assertLastModified(21, file);
175 })
176 .thenAlways(function() { mockClock.uninstall(); });
177
178 mockClock.tick();
179 return promise;
180 }
181
182
183 function testAbort() {
184 var observer = createObserver(writer);
185
186 mockClock.install();
187 mockClock.tick(13);
188
189 var promise = writeString(writer, 'hello world');
190 assertEquals(ReadyState.WRITING, writer.getReadyState());
191 writer.abort();
192
193 promise = promise
194 .then(function() {
195 assertEquals('', file.toString());
196
197 assertEquals(ReadyState.DONE, writer.getReadyState());
198 assertPositionAndLength(0, 0, writer);
199 assertLastModified(0, file);
200
201 assertArrayEquals(
202 [EventType.ERROR, EventType.ABORT, EventType.WRITE_END],
203 goog.array.map(observer.getEvents(), function(e) {
204 return e.type;
205 }));
206 })
207 .thenAlways(function() { mockClock.uninstall(); });
208
209 mockClock.tick();
210 return promise;
211 }
212
213 function testTruncate() {
214 // Create the event observer after the initial write is complete.
215 var observer;
216
217 mockClock.install();
218
219 var promise =
220 writeString(writer, 'hello world')
221 .then(function() {
222 observer = createObserver(writer);
223
224 writer.truncate(5);
225 assertEquals(ReadyState.WRITING, writer.getReadyState());
226 assertPositionAndLength(11, 11, writer);
227 assertLastModified(0, file);
228
229 var promise = waitForEvent(writer, EventType.WRITE_END);
230 mockClock.tick();
231 return promise;
232 })
233 .then(function() {
234 assertEquals('hello', file.toString());
235
236 assertEquals(ReadyState.DONE, writer.getReadyState());
237 assertPositionAndLength(5, 5, writer);
238 assertLastModified(7, file);
239
240 assertArrayEquals(
241 [EventType.WRITE_START, EventType.WRITE, EventType.WRITE_END],
242 goog.array.map(
243 observer.getEvents(), function(e) { return e.type; }));
244
245 writer.truncate(10);
246 var promise = waitForEvent(writer, EventType.WRITE_END);
247 mockClock.tick(1);
248 return promise;
249 })
250 .then(function() {
251 assertEquals('hello\0\0\0\0\0', file.toString());
252 assertLastModified(8, file);
253 })
254 .thenAlways(function() { mockClock.uninstall(); });
255
256 mockClock.tick(7);
257 return promise;
258 }
259
260
261 function testAbortBeforeWrite() {
262 var err = assertThrows(function() { writer.abort(); });
263 assertEquals(goog.fs.Error.ErrorCode.INVALID_STATE, err.code);
264 }
265
266
267 function testAbortAfterWrite() {
268 return writeString(writer, 'hello world').then(function() {
269 var err = assertThrows(function() { writer.abort(); });
270 assertEquals(goog.fs.Error.ErrorCode.INVALID_STATE, err.code);
271 });
272 }
273
274
275 function testWriteDuringWrite() {
276 writer.write(new goog.testing.fs.Blob('hello'));
277 var err = assertThrows(function() {
278 writer.write(new goog.testing.fs.Blob('world'));
279 });
280 assertEquals(goog.fs.Error.ErrorCode.INVALID_STATE, err.code);
281 }
282
283
284 function testSeekDuringWrite() {
285 writer.write(new goog.testing.fs.Blob('hello world'));
286 var err = assertThrows(function() { writer.seek(5); });
287 assertEquals(goog.fs.Error.ErrorCode.INVALID_STATE, err.code);
288 }
289
290
291 function testTruncateDuringWrite() {
292 writer.write(new goog.testing.fs.Blob('hello world'));
293 var err = assertThrows(function() { writer.truncate(5); });
294 assertEquals(goog.fs.Error.ErrorCode.INVALID_STATE, err.code);
295 }
296
297
298 function waitForEvent(target, type) {
299 return new goog.Promise(function(resolve, reject) {
300 goog.events.listenOnce(target, type, resolve);
301 });
302 }
303
304
305 function assertPositionAndLength(expectedPosition, expectedLength, writer) {
306 assertEquals(expectedPosition, writer.getPosition());
307 assertEquals(expectedLength, writer.getLength());
308 }
309
310
311 function assertLastModified(expectedTime, file) {
312 assertEquals(expectedTime, file.lastModifiedDate.getTime());
313 }
314
315
316 function writeString(writer, str) {
317 var promise = waitForEvent(writer, goog.fs.FileSaver.EventType.WRITE_END);
318 writer.write(new goog.testing.fs.Blob(str));
319 return promise;
320 }
321
322
323 function createObserver(writer) {
324 // Observe all file events fired by the FileWriter.
325 var observer = new goog.testing.events.EventObserver();
326 goog.events.listen(writer, goog.object.getValues(EventType), observer);
327 return observer;
328 }