newjs 1.7.2 → 1.7.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. data/Manifest.txt +13 -2
  2. data/Rakefile +11 -20
  3. data/app_generators/newjs/templates/test/assets/jsunittest.js +173 -135
  4. data/app_generators/newjs_iphone/templates/Html/test/assets/jsunittest.js +173 -135
  5. data/app_generators/newjs_screwunit/USAGE +5 -0
  6. data/app_generators/newjs_screwunit/newjs_screwunit_generator.rb +61 -0
  7. data/app_generators/newjs_screwunit/templates/Rakefile.erb +34 -0
  8. data/bin/newjs_screwunit +17 -0
  9. data/features/development.feature +5 -5
  10. data/features/imported_files_for_generators.feature +2 -2
  11. data/features/newjs_screwunit.feature +18 -0
  12. data/features/step_definitions/cli_steps.rb +9 -0
  13. data/features/{steps/common.rb → step_definitions/common_steps.rb} +39 -81
  14. data/features/step_definitions/file_comparison_steps.rb +10 -0
  15. data/features/support/common.rb +29 -0
  16. data/features/support/env.rb +15 -0
  17. data/features/support/matchers.rb +11 -0
  18. data/lib/newjs.rb +1 -1
  19. data/rack_generators/javascript_test/templates/assets/jsunittest.js +173 -135
  20. data/rails_generators/javascript_test/templates/assets/jsunittest.js +173 -135
  21. data/test/test_newjs_screwunit_generator.rb +43 -0
  22. data/vendor/jsunittest/History.txt +9 -0
  23. data/vendor/jsunittest/Rakefile +1 -1
  24. data/vendor/jsunittest/dist/jsunittest-0.7.3.js +1042 -0
  25. data/vendor/jsunittest/dist/jsunittest.js +173 -135
  26. data/vendor/jsunittest/src/ajax.js +2 -1
  27. data/vendor/jsunittest/src/assertions.js +49 -78
  28. data/vendor/jsunittest/src/common.js +83 -24
  29. data/vendor/jsunittest/src/jsunittest.js +7 -998
  30. data/vendor/jsunittest/src/logger.js +6 -6
  31. data/vendor/jsunittest/src/message_template.js +1 -1
  32. data/vendor/jsunittest/src/prototype/event.js +2 -2
  33. data/vendor/jsunittest/src/prototype/template.js +7 -6
  34. data/vendor/jsunittest/src/runner.js +13 -12
  35. data/vendor/jsunittest/src/test_case.js +11 -6
  36. data/vendor/jsunittest/test/unit/assertions_test.html +9 -1
  37. data/vendor/jsunittest/test/unit/common_test.html +9 -1
  38. data/vendor/jsunittest/test/unit/logger_test.html +2 -2
  39. data/vendor/jsunittest/test/unit/message_template_test.html +2 -2
  40. data/vendor/jsunittest/test/unit/runner_test.html +2 -2
  41. data/vendor/jsunittest/test/unit/template_test.html +2 -2
  42. data/vendor/jsunittest/test/unit/test_case_test.html +24 -3
  43. data/vendor/jsunittest/website/images/logo_bundle.png +0 -0
  44. data/vendor/jsunittest/website/index.html +3 -3
  45. data/vendor/jsunittest/website/index.txt +1 -1
  46. data/vendor/jsunittest/website/stylesheets/screen.css +3 -0
  47. data/vendor/jsunittest/website/tmbundle/JavaScript Unit Testing.tmbundle.tar.gz +0 -0
  48. metadata +20 -14
  49. data/features/steps/env.rb +0 -6
@@ -111,8 +111,9 @@ JsUnitTest.ajax = function( options ) {
111
111
 
112
112
  // If the specified type is "script", execute the returned text
113
113
  // response as if it was JavaScript
114
- if ( type == "script" )
114
+ if ( type == "script" ) {
115
115
  eval.call( window, data );
116
+ }
116
117
 
117
118
  // Return the response data (either an XML Document or a text string)
118
119
  return data;
@@ -4,172 +4,142 @@ JsUnitTest.Unit.Assertions = {
4
4
  return (message ? message + '\n' : '') +
5
5
  new JsUnitTest.Unit.MessageTemplate(template).evaluate(args);
6
6
  },
7
-
7
+
8
8
  flunk: function(message) {
9
- this.assertBlock(message || 'Flunked', function() { return false });
9
+ this.assertBlock(message || 'Flunked', function() { return false; });
10
10
  },
11
11
 
12
12
  assertBlock: function(message, block) {
13
13
  try {
14
14
  block.call(this) ? this.pass() : this.fail(message);
15
- } catch(e) { this.error(e) }
15
+ } catch(e) { this.error(e); }
16
16
  },
17
17
 
18
18
  assert: function(expression, message) {
19
19
  message = this.buildMessage(message || 'assert', 'got <?>', expression);
20
- this.assertBlock(message, function() { return expression });
20
+ this.assertBlock(message, function() { return expression; });
21
21
  },
22
22
 
23
23
  assertEqual: function(expected, actual, message) {
24
24
  message = this.buildMessage(message || 'assertEqual', 'expected <?>, actual: <?>', expected, actual);
25
- this.assertBlock(message, function() { return expected == actual });
25
+ this.assertBlock(message, function() { return expected == actual; });
26
26
  },
27
27
 
28
28
  assertNotEqual: function(expected, actual, message) {
29
29
  message = this.buildMessage(message || 'assertNotEqual', 'expected <?>, actual: <?>', expected, actual);
30
- this.assertBlock(message, function() { return expected != actual });
30
+ this.assertBlock(message, function() { return expected != actual; });
31
31
  },
32
32
 
33
33
  assertEnumEqual: function(expected, actual, message) {
34
34
  message = this.buildMessage(message || 'assertEnumEqual', 'expected <?>, actual: <?>', expected, actual);
35
- var expected_array = JsUnitTest.flattenArray(expected);
36
- var actual_array = JsUnitTest.flattenArray(actual);
37
- this.assertBlock(message, function() {
38
- if (expected_array.length == actual_array.length) {
39
- for (var i=0; i < expected_array.length; i++) {
40
- if (expected_array[i] != actual_array[i]) return false;
41
- };
42
- return true;
43
- }
44
- return false;
45
- });
35
+ this.assertBlock(message, function() { return JsUnitTest.areArraysEqual(expected, actual); });
46
36
  },
47
37
 
48
38
  assertEnumNotEqual: function(expected, actual, message) {
49
39
  message = this.buildMessage(message || 'assertEnumNotEqual', '<?> was the same as <?>', expected, actual);
50
- var expected_array = JsUnitTest.flattenArray(expected);
51
- var actual_array = JsUnitTest.flattenArray(actual);
52
- this.assertBlock(message, function() {
53
- if (expected_array.length == actual_array.length) {
54
- for (var i=0; i < expected_array.length; i++) {
55
- if (expected_array[i] != actual_array[i]) return true;
56
- };
57
- return false;
58
- }
59
- return true;
60
- });
40
+ this.assertBlock(message, function() { return JsUnitTest.areArraysNotEqual(expected, actual); });
61
41
  },
62
42
 
63
43
  assertHashEqual: function(expected, actual, message) {
64
- message = this.buildMessage(message || 'assertHashEqual', 'expected <?>, actual: <?>', expected, actual);
65
- var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
66
- var actual_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
67
- var block = function() {
68
- if (expected_array.length == actual_array.length) {
69
- for (var i=0; i < expected_array.length; i++) {
70
- if (expected_array[i] != actual_array[i]) return false;
71
- };
72
- return true;
73
- }
74
- return false;
75
- };
76
- this.assertBlock(message, block);
44
+ message = this.buildMessage(message || 'assertHashEqual', 'expected <?>, actual: <?>', JsUnitTest.inspect(expected), JsUnitTest.inspect(actual));
45
+ this.assertBlock(message, function() { return JsUnitTest.areHashesEqual(expected, actual); });
77
46
  },
78
47
 
79
48
  assertHashNotEqual: function(expected, actual, message) {
80
- message = this.buildMessage(message || 'assertHashNotEqual', '<?> was the same as <?>', expected, actual);
81
- var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
82
- var actual_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
83
- // from now we recursively zip & compare nested arrays
84
- var block = function() {
85
- if (expected_array.length == actual_array.length) {
86
- for (var i=0; i < expected_array.length; i++) {
87
- if (expected_array[i] != actual_array[i]) return true;
88
- };
89
- return false;
90
- }
91
- return true;
92
- };
93
- this.assertBlock(message, block);
49
+ message = this.buildMessage(message || 'assertHashNotEqual', '<?> was the same as <?>', JsUnitTest.inspect(expected), JsUnitTest.inspect(actual));
50
+ this.assertBlock(message, function() { return JsUnitTest.areHashesNotEqual(expected, actual); });
94
51
  },
95
52
 
96
53
  assertIdentical: function(expected, actual, message) {
97
54
  message = this.buildMessage(message || 'assertIdentical', 'expected <?>, actual: <?>', expected, actual);
98
- this.assertBlock(message, function() { return expected === actual });
55
+ this.assertBlock(message, function() { return expected === actual; });
99
56
  },
100
57
 
101
58
  assertNotIdentical: function(expected, actual, message) {
102
59
  message = this.buildMessage(message || 'assertNotIdentical', 'expected <?>, actual: <?>', expected, actual);
103
- this.assertBlock(message, function() { return expected !== actual });
60
+ this.assertBlock(message, function() { return expected !== actual; });
104
61
  },
105
62
 
106
63
  assertNull: function(obj, message) {
107
64
  message = this.buildMessage(message || 'assertNull', 'got <?>', obj);
108
- this.assertBlock(message, function() { return obj === null });
65
+ this.assertBlock(message, function() { return obj === null; });
109
66
  },
110
67
 
111
68
  assertNotNull: function(obj, message) {
112
69
  message = this.buildMessage(message || 'assertNotNull', 'got <?>', obj);
113
- this.assertBlock(message, function() { return obj !== null });
70
+ this.assertBlock(message, function() { return obj !== null; });
114
71
  },
115
72
 
116
73
  assertUndefined: function(obj, message) {
117
74
  message = this.buildMessage(message || 'assertUndefined', 'got <?>', obj);
118
- this.assertBlock(message, function() { return typeof obj == "undefined" });
75
+ this.assertBlock(message, function() { return typeof obj == "undefined"; });
119
76
  },
120
77
 
121
78
  assertNotUndefined: function(obj, message) {
122
79
  message = this.buildMessage(message || 'assertNotUndefined', 'got <?>', obj);
123
- this.assertBlock(message, function() { return typeof obj != "undefined" });
80
+ this.assertBlock(message, function() { return typeof obj != "undefined"; });
124
81
  },
125
82
 
126
83
  assertNullOrUndefined: function(obj, message) {
127
84
  message = this.buildMessage(message || 'assertNullOrUndefined', 'got <?>', obj);
128
- this.assertBlock(message, function() { return obj == null });
85
+ this.assertBlock(message, function() { return obj == null; });
129
86
  },
130
87
 
131
88
  assertNotNullOrUndefined: function(obj, message) {
132
89
  message = this.buildMessage(message || 'assertNotNullOrUndefined', 'got <?>', obj);
133
- this.assertBlock(message, function() { return obj != null });
90
+ this.assertBlock(message, function() { return obj != null; });
134
91
  },
135
92
 
136
93
  assertMatch: function(expected, actual, message) {
137
94
  message = this.buildMessage(message || 'assertMatch', 'regex <?> did not match <?>', expected, actual);
138
- this.assertBlock(message, function() { return new RegExp(expected).exec(actual) });
95
+ this.assertBlock(message, function() { return new RegExp(expected).exec(actual); });
139
96
  },
140
97
 
141
98
  assertNoMatch: function(expected, actual, message) {
142
99
  message = this.buildMessage(message || 'assertNoMatch', 'regex <?> matched <?>', expected, actual);
143
- this.assertBlock(message, function() { return !(new RegExp(expected).exec(actual)) });
100
+ this.assertBlock(message, function() { return !(new RegExp(expected).exec(actual)); });
144
101
  },
145
102
 
146
103
  assertHasClass: function(element, klass, message) {
147
104
  element = JsUnitTest.$(element);
148
105
  message = this.buildMessage(message || 'assertHasClass', '? doesn\'t have class <?>.', element, klass);
149
- this.assertBlock(message, function() {
150
- return !!element.className.match(new RegExp(klass))
106
+ this.assertBlock(message, function() {
107
+ var elementClassName = element.className;
108
+ return (elementClassName.length > 0 && (elementClassName == klass ||
109
+ new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
110
+ // return !!element.className.match(new RegExp(klass))
111
+ });
112
+ },
113
+
114
+ assertNotHasClass: function(element, klass, message) {
115
+ element = JsUnitTest.$(element);
116
+ message = this.buildMessage(message || 'assertNotHasClass', '? does have class <?>.', element, klass);
117
+ this.assertBlock(message, function() {
118
+ var elementClassName = element.className;
119
+ return !(elementClassName.length > 0 && (elementClassName == klass ||
120
+ new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
151
121
  });
152
122
  },
153
123
 
154
124
  assertHidden: function(element, message) {
155
125
  element = JsUnitTest.$(element);
156
126
  message = this.buildMessage(message || 'assertHidden', '? isn\'t hidden.', element);
157
- this.assertBlock(message, function() { return !element.style.display || element.style.display == 'none' });
127
+ this.assertBlock(message, function() { return !element.style.display || element.style.display == 'none'; });
158
128
  },
159
129
 
160
130
  assertInstanceOf: function(expected, actual, message) {
161
131
  message = this.buildMessage(message || 'assertInstanceOf', '<?> was not an instance of the expected type', actual);
162
- this.assertBlock(message, function() { return actual instanceof expected });
132
+ this.assertBlock(message, function() { return actual instanceof expected; });
163
133
  },
164
134
 
165
135
  assertNotInstanceOf: function(expected, actual, message) {
166
136
  message = this.buildMessage(message || 'assertNotInstanceOf', '<?> was an instance of the expected type', actual);
167
- this.assertBlock(message, function() { return !(actual instanceof expected) });
137
+ this.assertBlock(message, function() { return !(actual instanceof expected); });
168
138
  },
169
139
 
170
140
  assertRespondsTo: function(method, obj, message) {
171
141
  message = this.buildMessage(message || 'assertRespondsTo', 'object doesn\'t respond to <?>', method);
172
- this.assertBlock(message, function() { return (method in obj && typeof obj[method] == 'function') });
142
+ this.assertBlock(message, function() { return (method in obj && typeof obj[method] == 'function'); });
173
143
  },
174
144
 
175
145
  assertRaise: function(exceptionName, method, message) {
@@ -179,8 +149,8 @@ JsUnitTest.Unit.Assertions = {
179
149
  method();
180
150
  return false;
181
151
  } catch(e) {
182
- if (e.name == exceptionName) return true;
183
- else throw e;
152
+ if (e.name == exceptionName) {return true;}
153
+ else {throw e;}
184
154
  }
185
155
  };
186
156
  this.assertBlock(message, block);
@@ -198,22 +168,23 @@ JsUnitTest.Unit.Assertions = {
198
168
 
199
169
  _isVisible: function(element) {
200
170
  element = JsUnitTest.$(element);
201
- if(!element.parentNode) return true;
171
+ if(!element.parentNode) {return true;}
202
172
  this.assertNotNull(element);
203
- if(element.style && (element.style.display == 'none'))
173
+ if(element.style && (element.style.display == 'none')) {
204
174
  return false;
175
+ }
205
176
 
206
177
  return arguments.callee.call(this, element.parentNode);
207
178
  },
208
179
 
209
180
  assertVisible: function(element, message) {
210
181
  message = this.buildMessage(message, '? was not visible.', element);
211
- this.assertBlock(message, function() { return this._isVisible(element) });
182
+ this.assertBlock(message, function() { return this._isVisible(element); });
212
183
  },
213
184
 
214
185
  assertNotVisible: function(element, message) {
215
186
  message = this.buildMessage(message, '? was not hidden and didn\'t have a hidden parent either.', element);
216
- this.assertBlock(message, function() { return !this._isVisible(element) });
187
+ this.assertBlock(message, function() { return !this._isVisible(element); });
217
188
  },
218
189
 
219
190
  assertElementsMatch: function() {
@@ -234,7 +205,7 @@ JsUnitTest.Unit.Assertions = {
234
205
  message = this.buildMessage('assertElementsMatch', 'In index <?>: expected <?> but got ?', index, expression, element);
235
206
  this.flunk(message);
236
207
  pass = false;
237
- };
208
+ }
238
209
  this.assert(pass, "Expected all elements to match.");
239
210
  },
240
211
 
@@ -2,34 +2,57 @@ var JsUnitTest = {
2
2
  Unit: {},
3
3
  inspect: function(object) {
4
4
  try {
5
- if (typeof object == "undefined") return 'undefined';
6
- if (object === null) return 'null';
5
+ if (typeof object == "undefined") {return 'undefined';}
6
+ if (object === null) {return 'null';}
7
7
  if (typeof object == "string") {
8
8
  var useDoubleQuotes = arguments[1];
9
9
  var escapedString = this.gsub(object, /[\x00-\x1f\\]/, function(match) {
10
- var character = String.specialChar[match[0]];
11
- return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
10
+ var character = {
11
+ '\b': '\\b',
12
+ '\t': '\\t',
13
+ '\n': '\\n',
14
+ '\f': '\\f',
15
+ '\r': '\\r',
16
+ '\\': '\\\\'
17
+ }[match[0]];
18
+ return character ? character : '\\u00' + JsUnitTest.toHexString(match[0].charCodeAt());
12
19
  });
13
- if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
20
+ if (useDoubleQuotes) {return '"' + escapedString.replace(/"/g, '\\"') + '"';}
14
21
  return "'" + escapedString.replace(/'/g, '\\\'') + "'";
15
- };
22
+ }
23
+ if (JsUnitTest.getClass(object) === 'Object') {
24
+ var keys_values = new Array(), prefix = 'Object: { ';
25
+ for (property in object) {
26
+ keys_values.push(property + ': ' + object[property]);
27
+ }
28
+ return (prefix + keys_values.join(', ') + ' }');
29
+ }
16
30
  return String(object);
17
31
  } catch (e) {
18
- if (e instanceof RangeError) return '...';
32
+ if (e instanceof RangeError) {return '...';}
19
33
  throw e;
20
34
  }
21
35
  },
22
- $: function(element) {
36
+
37
+ getClass: function(object) {
38
+ return Object.prototype.toString.call(object)
39
+ .match(/^\[object\s(.*)\]$/)[1];
40
+ },
41
+
42
+ $: function(element) {
23
43
  if (arguments.length > 1) {
24
- for (var i = 0, elements = [], length = arguments.length; i < length; i++)
44
+ for (var i = 0, elements = [], length = arguments.length; i < length; i++) {
25
45
  elements.push(this.$(arguments[i]));
46
+ }
26
47
  return elements;
27
48
  }
28
- if (typeof element == "string")
49
+ if (typeof element == "string") {
29
50
  element = document.getElementById(element);
51
+ }
30
52
  return element;
31
53
  },
32
- gsub: function(source, pattern, replacement) {
54
+
55
+ gsub: function(source, pattern, replacement) {
33
56
  var result = '', match;
34
57
  replacement = arguments.callee.prepareReplacement(replacement);
35
58
 
@@ -51,15 +74,48 @@ var JsUnitTest = {
51
74
  escapeHTML: function(data) {
52
75
  return data.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
53
76
  },
77
+ toHexString : function(n) {
78
+ var string = n.toString(16);
79
+ return '00'.substring(string.length) + string;
80
+ },
54
81
  arrayfromargs: function(args) {
55
82
  var myarray = new Array();
56
83
  var i;
57
84
 
58
- for (i=0;i<args.length;i++)
59
- myarray[i] = args[i];
85
+ for (i=0;i<args.length;i++) {
86
+ myarray[i] = args[i];
87
+ }
60
88
 
61
89
  return myarray;
62
90
  },
91
+
92
+ // from now we recursively zip & compare nested arrays
93
+ areArraysEqual: function(expected, actual) {
94
+ var expected_array = JsUnitTest.flattenArray(expected);
95
+ var actual_array = JsUnitTest.flattenArray(actual);
96
+ if (expected_array.length == actual_array.length) {
97
+ for (var i=0; i < expected_array.length; i++) {
98
+ if (expected_array[i] != actual_array[i]) {return false;}
99
+ }
100
+ return true;
101
+ }
102
+ return false;
103
+ },
104
+
105
+ areArraysNotEqual: function(expected, actual) {
106
+ return !this.areArraysEqual(expected, actual);
107
+ },
108
+
109
+ areHashesEqual: function(expected, actual) {
110
+ var expected_array = JsUnitTest.hashToSortedArray(expected);
111
+ var actual_array = JsUnitTest.hashToSortedArray(actual);
112
+ return this.areArraysEqual(expected_array, actual_array);
113
+ },
114
+
115
+ areHashesNotEqual: function(expected, actual) {
116
+ return !this.areHashesEqual(expected, actual);
117
+ },
118
+
63
119
  hashToSortedArray: function(hash) {
64
120
  var results = [];
65
121
  for (key in hash) {
@@ -77,7 +133,7 @@ var JsUnitTest = {
77
133
  } else {
78
134
  results.push(object);
79
135
  }
80
- };
136
+ }
81
137
  return results;
82
138
  },
83
139
  selectorMatch: function(expression, element) {
@@ -142,7 +198,7 @@ var JsUnitTest = {
142
198
 
143
199
  var match = true, name, matches;
144
200
  for (var i = 0, token; token = tokens[i]; i++) {
145
- name = token[0], matches = token[1];
201
+ name = token[0]; matches = token[1];
146
202
  if (!assertions[name](element, matches)) {
147
203
  match = false; break;
148
204
  }
@@ -150,10 +206,11 @@ var JsUnitTest = {
150
206
 
151
207
  return match;
152
208
  },
209
+
153
210
  toQueryParams: function(query, separator) {
154
211
  var query = query || window.location.search;
155
212
  var match = query.replace(/^\s+/, '').replace(/\s+$/, '').match(/([^?#]*)(#.*)?$/);
156
- if (!match) return { };
213
+ if (!match) {return { };}
157
214
 
158
215
  var hash = {};
159
216
  var parts = match[1].split(separator || '&');
@@ -162,18 +219,20 @@ var JsUnitTest = {
162
219
  if (pair[0]) {
163
220
  var key = decodeURIComponent(pair.shift());
164
221
  var value = pair.length > 1 ? pair.join('=') : pair[0];
165
- if (value != undefined) value = decodeURIComponent(value);
222
+ if (value != undefined) {value = decodeURIComponent(value);}
166
223
 
167
224
  if (key in hash) {
168
225
  var object = hash[key];
169
226
  var isArray = object != null && typeof object == "object" &&
170
- 'splice' in object && 'join' in object
171
- if (!isArray) hash[key] = [hash[key]];
227
+ 'splice' in object && 'join' in object;
228
+ if (!isArray) {hash[key] = [hash[key]];}
172
229
  hash[key].push(value);
173
230
  }
174
- else hash[key] = value;
231
+ else {
232
+ hash[key] = value;
233
+ }
175
234
  }
176
- };
235
+ }
177
236
  return hash;
178
237
  },
179
238
 
@@ -185,7 +244,7 @@ var JsUnitTest = {
185
244
  };
186
245
 
187
246
  JsUnitTest.gsub.prepareReplacement = function(replacement) {
188
- if (typeof replacement == "function") return replacement;
247
+ if (typeof replacement == "function") {return replacement;}
189
248
  var template = new Template(replacement);
190
- return function(match) { return template.evaluate(match) };
191
- };
249
+ return function(match) { return template.evaluate(match); };
250
+ };