new 0.0.6 → 0.0.7
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.
- checksums.yaml +4 -4
- data/.gitmodules +3 -0
- data/.new +1 -1
- data/Gemfile.lock +25 -20
- data/Guardfile +6 -4
- data/README.md +9 -2
- data/doc/.git +1 -0
- data/doc/Gemfile.html +125 -0
- data/doc/Gemfile_lock.html +198 -0
- data/doc/Guardfile.html +134 -0
- data/doc/InterpolateSpec.html +116 -0
- data/doc/LICENSE_txt.html +132 -0
- data/doc/New/Cli.html +290 -0
- data/doc/New/Dsl.html +185 -0
- data/doc/New/Interpolate.html +238 -0
- data/doc/New/Project.html +171 -0
- data/doc/New/Task/CustomBarTask.html +154 -0
- data/doc/New/Task/FooTask.html +168 -0
- data/doc/New/Task/Gem.html +197 -0
- data/doc/New/Task/TaskSpec.html +168 -0
- data/doc/New/Task.html +380 -0
- data/doc/New/Template.html +234 -0
- data/doc/New/Version.html +277 -0
- data/doc/New.html +377 -0
- data/doc/Object.html +200 -0
- data/doc/README_md.html +292 -0
- data/doc/VersionSpec.html +116 -0
- data/doc/created.rid +47 -0
- data/doc/fonts/Lato-Light.ttf +0 -0
- data/doc/fonts/Lato-LightItalic.ttf +0 -0
- data/doc/fonts/Lato-Regular.ttf +0 -0
- data/doc/fonts/Lato-RegularItalic.ttf +0 -0
- data/doc/fonts/SourceCodePro-Bold.ttf +0 -0
- data/doc/fonts/SourceCodePro-Regular.ttf +0 -0
- data/doc/fonts.css +167 -0
- data/doc/images/add.png +0 -0
- data/doc/images/arrow_up.png +0 -0
- data/doc/images/brick.png +0 -0
- data/doc/images/brick_link.png +0 -0
- data/doc/images/bug.png +0 -0
- data/doc/images/bullet_black.png +0 -0
- data/doc/images/bullet_toggle_minus.png +0 -0
- data/doc/images/bullet_toggle_plus.png +0 -0
- data/doc/images/date.png +0 -0
- data/doc/images/delete.png +0 -0
- data/doc/images/find.png +0 -0
- data/doc/images/loadingAnimation.gif +0 -0
- data/doc/images/macFFBgHack.png +0 -0
- data/doc/images/package.png +0 -0
- data/doc/images/page_green.png +0 -0
- data/doc/images/page_white_text.png +0 -0
- data/doc/images/page_white_width.png +0 -0
- data/doc/images/plugin.png +0 -0
- data/doc/images/ruby.png +0 -0
- data/doc/images/tag_blue.png +0 -0
- data/doc/images/tag_green.png +0 -0
- data/doc/images/transparent.png +0 -0
- data/doc/images/wrench.png +0 -0
- data/doc/images/wrench_orange.png +0 -0
- data/doc/images/zoom.png +0 -0
- data/doc/index.html +142 -0
- data/doc/js/darkfish.js +140 -0
- data/doc/js/jquery.js +18 -0
- data/doc/js/navigation.js +142 -0
- data/doc/js/search.js +109 -0
- data/doc/js/search_index.js +1 -0
- data/doc/js/searcher.js +228 -0
- data/doc/rdoc.css +580 -0
- data/doc/spec/fixtures/custom/templates/custom_bar_template/custom_bar_txt.html +110 -0
- data/doc/table_of_contents.html +324 -0
- data/doc/tasks/gem/README_md.html +150 -0
- data/doc/templates/js/Gemfile.html +147 -0
- data/doc/templates/js/Guardfile.html +117 -0
- data/doc/templates/js/lib/README_md.html +114 -0
- data/doc/templates/js/spec/spec_helper_js_coffee.html +110 -0
- data/doc/templates/js/spec/vendor/chai_js.html +3864 -0
- data/doc/templates/js/spec/vendor/sinon-chai_js.html +222 -0
- data/doc/templates/js/spec/vendor/sinon_js.html +4358 -0
- data/doc/templates/js/src/README_md.html +125 -0
- data/lib/new/task.rb +2 -4
- data/lib/new/template.rb +1 -1
- data/lib/new/version.rb +27 -19
- data/spec/fixtures/tasks/foo_task/Gemfile +5 -0
- data/spec/lib/new/version_spec.rb +10 -15
- data/spec/spec_helper.rb +22 -1
- data/tasks/gem/gem.rb +44 -8
- data/tasks/gem/gem_spec.rb +139 -0
- metadata +233 -3
|
@@ -0,0 +1,3864 @@
|
|
|
1
|
+
<!DOCTYPE html>
|
|
2
|
+
|
|
3
|
+
<html>
|
|
4
|
+
<head>
|
|
5
|
+
<meta charset="UTF-8">
|
|
6
|
+
|
|
7
|
+
<title>chai.js - RDoc Documentation</title>
|
|
8
|
+
|
|
9
|
+
<link href="../../../../fonts.css" rel="stylesheet">
|
|
10
|
+
<link href="../../../../rdoc.css" rel="stylesheet">
|
|
11
|
+
|
|
12
|
+
<script type="text/javascript">
|
|
13
|
+
var rdoc_rel_prefix = "../../../../";
|
|
14
|
+
</script>
|
|
15
|
+
|
|
16
|
+
<script src="../../../../js/jquery.js"></script>
|
|
17
|
+
<script src="../../../../js/navigation.js"></script>
|
|
18
|
+
<script src="../../../../js/search_index.js"></script>
|
|
19
|
+
<script src="../../../../js/search.js"></script>
|
|
20
|
+
<script src="../../../../js/searcher.js"></script>
|
|
21
|
+
<script src="../../../../js/darkfish.js"></script>
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
<body id="top" role="document" class="file">
|
|
25
|
+
<nav role="navigation">
|
|
26
|
+
<div id="project-navigation">
|
|
27
|
+
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
|
|
28
|
+
<h2>
|
|
29
|
+
<a href="../../../../index.html" rel="home">Home</a>
|
|
30
|
+
</h2>
|
|
31
|
+
|
|
32
|
+
<div id="table-of-contents-navigation">
|
|
33
|
+
<a href="../../../../table_of_contents.html#pages">Pages</a>
|
|
34
|
+
<a href="../../../../table_of_contents.html#classes">Classes</a>
|
|
35
|
+
<a href="../../../../table_of_contents.html#methods">Methods</a>
|
|
36
|
+
</div>
|
|
37
|
+
</div>
|
|
38
|
+
|
|
39
|
+
<div id="search-section" role="search" class="project-section initially-hidden">
|
|
40
|
+
<form action="#" method="get" accept-charset="utf-8">
|
|
41
|
+
<div id="search-field-wrapper">
|
|
42
|
+
<input id="search-field" role="combobox" aria-label="Search"
|
|
43
|
+
aria-autocomplete="list" aria-controls="search-results"
|
|
44
|
+
type="text" name="search" placeholder="Search" spellcheck="false"
|
|
45
|
+
title="Type to search, Up and Down to navigate, Enter to load">
|
|
46
|
+
</div>
|
|
47
|
+
|
|
48
|
+
<ul id="search-results" aria-label="Search Results"
|
|
49
|
+
aria-busy="false" aria-expanded="false"
|
|
50
|
+
aria-atomic="false" class="initially-hidden"></ul>
|
|
51
|
+
</form>
|
|
52
|
+
</div>
|
|
53
|
+
|
|
54
|
+
</div>
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
<div id="project-metadata">
|
|
59
|
+
<div id="fileindex-section" class="nav-section">
|
|
60
|
+
<h3>Pages</h3>
|
|
61
|
+
|
|
62
|
+
<ul class="link-list">
|
|
63
|
+
|
|
64
|
+
<li><a href="../../../../Gemfile.html">Gemfile</a>
|
|
65
|
+
|
|
66
|
+
<li><a href="../../../../Gemfile_lock.html">Gemfile.lock</a>
|
|
67
|
+
|
|
68
|
+
<li><a href="../../../../Guardfile.html">Guardfile</a>
|
|
69
|
+
|
|
70
|
+
<li><a href="../../../../LICENSE_txt.html">LICENSE</a>
|
|
71
|
+
|
|
72
|
+
<li><a href="../../../../README_md.html">README</a>
|
|
73
|
+
|
|
74
|
+
<li><a href="../../../../spec/fixtures/custom/templates/custom_bar_template/custom_bar_txt.html">custom_bar</a>
|
|
75
|
+
|
|
76
|
+
<li><a href="../../../../tasks/gem/README_md.html">README</a>
|
|
77
|
+
|
|
78
|
+
<li><a href="../../../../templates/js/Gemfile.html">Gemfile</a>
|
|
79
|
+
|
|
80
|
+
<li><a href="../../../../templates/js/Guardfile.html">Guardfile</a>
|
|
81
|
+
|
|
82
|
+
<li><a href="../../../../templates/js/lib/README_md.html">README</a>
|
|
83
|
+
|
|
84
|
+
<li><a href="../../../../templates/js/spec/spec_helper_js_coffee.html">spec_helper.js.coffee</a>
|
|
85
|
+
|
|
86
|
+
<li><a href="../../../../templates/js/spec/vendor/chai_js.html">chai.js</a>
|
|
87
|
+
|
|
88
|
+
<li><a href="../../../../templates/js/spec/vendor/sinon-chai_js.html">sinon-chai.js</a>
|
|
89
|
+
|
|
90
|
+
<li><a href="../../../../templates/js/spec/vendor/sinon_js.html">sinon.js</a>
|
|
91
|
+
|
|
92
|
+
<li><a href="../../../../templates/js/src/README_md.html">README</a>
|
|
93
|
+
|
|
94
|
+
</ul>
|
|
95
|
+
</div>
|
|
96
|
+
|
|
97
|
+
</div>
|
|
98
|
+
</nav>
|
|
99
|
+
|
|
100
|
+
<main role="main" aria-label="Page templates/js/spec/vendor/chai.js">
|
|
101
|
+
|
|
102
|
+
<p>! function(name, context, definition) {</p>
|
|
103
|
+
|
|
104
|
+
<pre class="ruby"><span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">require</span> <span class="ruby-operator">===</span> <span class="ruby-string">'function'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">exports</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">module</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span>) {
|
|
105
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">definition</span>();
|
|
106
|
+
} <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">define</span> <span class="ruby-operator">===</span> <span class="ruby-string">'function'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">define</span>.<span class="ruby-identifier">amd</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span>) {
|
|
107
|
+
<span class="ruby-identifier">define</span>(<span class="ruby-identifier">function</span>() {
|
|
108
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">definition</span>();
|
|
109
|
+
});
|
|
110
|
+
} <span class="ruby-keyword">else</span> {
|
|
111
|
+
<span class="ruby-identifier">context</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">definition</span>();
|
|
112
|
+
}
|
|
113
|
+
</pre>
|
|
114
|
+
|
|
115
|
+
<p>}('chai', this, function() {</p>
|
|
116
|
+
|
|
117
|
+
<pre class="ruby"><span class="ruby-identifier">function</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">p</span>) {
|
|
118
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">path</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">resolve</span>(<span class="ruby-identifier">p</span>),
|
|
119
|
+
<span class="ruby-identifier">mod</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">path</span>];
|
|
120
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">mod</span>) <span class="ruby-identifier">throw</span> <span class="ruby-identifier">new</span> <span class="ruby-constant">Error</span>(<span class="ruby-string">'failed to require "'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">p</span> <span class="ruby-operator">+</span> <span class="ruby-string">'"'</span>);
|
|
121
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>) {
|
|
122
|
+
<span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span> = {};
|
|
123
|
+
<span class="ruby-identifier">mod</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>, <span class="ruby-identifier">mod</span>, <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>.<span class="ruby-identifier">relative</span>(<span class="ruby-identifier">path</span>));
|
|
124
|
+
}
|
|
125
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>;
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span> = {};
|
|
129
|
+
|
|
130
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">resolve</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">path</span>) {
|
|
131
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">orig</span> = <span class="ruby-identifier">path</span>,
|
|
132
|
+
<span class="ruby-identifier">reg</span> = <span class="ruby-identifier">path</span> <span class="ruby-operator">+</span> <span class="ruby-string">'.js'</span>,
|
|
133
|
+
<span class="ruby-identifier">index</span> = <span class="ruby-identifier">path</span> <span class="ruby-operator">+</span> <span class="ruby-string">'/index.js'</span>;
|
|
134
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">reg</span>] <span class="ruby-operator">&&</span> <span class="ruby-identifier">reg</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">index</span>] <span class="ruby-operator">&&</span> <span class="ruby-identifier">index</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">orig</span>;
|
|
135
|
+
};
|
|
136
|
+
|
|
137
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">path</span>, <span class="ruby-identifier">fn</span>) {
|
|
138
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">path</span>] = <span class="ruby-identifier">fn</span>;
|
|
139
|
+
};
|
|
140
|
+
|
|
141
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">relative</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">parent</span>) {
|
|
142
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">function</span>(<span class="ruby-identifier">p</span>) {
|
|
143
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-string">'.'</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">p</span>.<span class="ruby-identifier">charAt</span>(<span class="ruby-value">0</span>)) <span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">p</span>);
|
|
144
|
+
|
|
145
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">path</span> = <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">'/'</span>),
|
|
146
|
+
<span class="ruby-identifier">segs</span> = <span class="ruby-identifier">p</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">'/'</span>);
|
|
147
|
+
<span class="ruby-identifier">path</span>.<span class="ruby-identifier">pop</span>();
|
|
148
|
+
|
|
149
|
+
<span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>; <span class="ruby-identifier">i</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">segs</span>.<span class="ruby-identifier">length</span>; <span class="ruby-identifier">i</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>) {
|
|
150
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">seg</span> = <span class="ruby-identifier">segs</span>[<span class="ruby-identifier">i</span>];
|
|
151
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-string">'..'</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">seg</span>) <span class="ruby-identifier">path</span>.<span class="ruby-identifier">pop</span>();
|
|
152
|
+
<span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-string">'.'</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">seg</span>) <span class="ruby-identifier">path</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">seg</span>);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">path</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">'/'</span>));
|
|
156
|
+
};
|
|
157
|
+
};
|
|
158
|
+
|
|
159
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">alias</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">from</span>, <span class="ruby-identifier">to</span>) {
|
|
160
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">fn</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">from</span>];
|
|
161
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">to</span>] = <span class="ruby-identifier">fn</span>;
|
|
162
|
+
};
|
|
163
|
+
|
|
164
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
165
|
+
<span class="ruby-operator">!</span>
|
|
166
|
+
<span class="ruby-identifier">chai</span>
|
|
167
|
+
<span class="ruby-constant">Copyright</span>(<span class="ruby-identifier">c</span>) <span class="ruby-value">2011</span><span class="ruby-operator">-</span><span class="ruby-value">2013</span> <span class="ruby-constant">Jake</span> <span class="ruby-constant">Luer</span> <span class="ruby-operator"><</span><span class="ruby-identifier">jake</span><span class="ruby-ivar">@alogicalparadox</span>.<span class="ruby-identifier">com</span><span class="ruby-operator">></span>
|
|
168
|
+
<span class="ruby-constant">MIT</span> <span class="ruby-constant">Licensed</span>
|
|
169
|
+
|
|
170
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">used</span> = [],
|
|
171
|
+
<span class="ruby-identifier">exports</span> = <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = {};
|
|
172
|
+
|
|
173
|
+
<span class="ruby-regexp">/*!
|
|
174
|
+
Chai version
|
|
175
|
+
/</span>
|
|
176
|
+
|
|
177
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">version</span> = <span class="ruby-string">'1.5.0'</span>;
|
|
178
|
+
|
|
179
|
+
<span class="ruby-regexp">/*!
|
|
180
|
+
Primary `Assertion` prototype
|
|
181
|
+
/</span>
|
|
182
|
+
|
|
183
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-constant">Assertion</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/assertion'</span>);
|
|
184
|
+
|
|
185
|
+
<span class="ruby-regexp">/*!
|
|
186
|
+
Assertion Error
|
|
187
|
+
/</span>
|
|
188
|
+
|
|
189
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-constant">AssertionError</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/error'</span>);
|
|
190
|
+
|
|
191
|
+
<span class="ruby-regexp">/*!
|
|
192
|
+
Utils for plugins (not exported)
|
|
193
|
+
/</span>
|
|
194
|
+
|
|
195
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">util</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/utils'</span>);
|
|
196
|
+
|
|
197
|
+
<span class="ruby-node">/**
|
|
198
|
+
# .use(function)
|
|
199
|
+
|
|
200
|
+
Provides a way to extend the internals of Chai
|
|
201
|
+
|
|
202
|
+
@param {Function}
|
|
203
|
+
@returns {this} for chaining
|
|
204
|
+
@api public
|
|
205
|
+
/</span>
|
|
206
|
+
|
|
207
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">fn</span>) {
|
|
208
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!~</span><span class="ruby-identifier">used</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">fn</span>)) {
|
|
209
|
+
<span class="ruby-identifier">fn</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">util</span>);
|
|
210
|
+
<span class="ruby-identifier">used</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">fn</span>);
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
214
|
+
};
|
|
215
|
+
|
|
216
|
+
<span class="ruby-regexp">/*!
|
|
217
|
+
Core Assertions
|
|
218
|
+
/</span>
|
|
219
|
+
|
|
220
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">core</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/core/assertions'</span>);
|
|
221
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">core</span>);
|
|
222
|
+
|
|
223
|
+
<span class="ruby-regexp">/*!
|
|
224
|
+
Expect interface
|
|
225
|
+
/</span>
|
|
226
|
+
|
|
227
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">expect</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/interface/expect'</span>);
|
|
228
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">expect</span>);
|
|
229
|
+
|
|
230
|
+
<span class="ruby-regexp">/*!
|
|
231
|
+
Should interface
|
|
232
|
+
/</span>
|
|
233
|
+
|
|
234
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">should</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/interface/should'</span>);
|
|
235
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">should</span>);
|
|
236
|
+
|
|
237
|
+
<span class="ruby-regexp">/*!
|
|
238
|
+
Assert interface
|
|
239
|
+
/</span>
|
|
240
|
+
|
|
241
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">assert</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./chai/interface/assert'</span>);
|
|
242
|
+
<span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">assert</span>);
|
|
243
|
+
|
|
244
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span>.<span class="ruby-identifier">js</span>
|
|
245
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/assertion.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
246
|
+
<span class="ruby-regexp">/*!
|
|
247
|
+
chai
|
|
248
|
+
http:/</span><span class="ruby-operator">/</span><span class="ruby-identifier">chaijs</span>.<span class="ruby-identifier">com</span>
|
|
249
|
+
<span class="ruby-constant">Copyright</span>(<span class="ruby-identifier">c</span>) <span class="ruby-value">2011</span><span class="ruby-operator">-</span><span class="ruby-value">2013</span> <span class="ruby-constant">Jake</span> <span class="ruby-constant">Luer</span> <span class="ruby-operator"><</span><span class="ruby-identifier">jake</span><span class="ruby-ivar">@alogicalparadox</span>.<span class="ruby-identifier">com</span><span class="ruby-operator">></span>
|
|
250
|
+
<span class="ruby-constant">MIT</span> <span class="ruby-constant">Licensed</span>
|
|
251
|
+
<span class="ruby-regexp">/
|
|
252
|
+
|
|
253
|
+
/</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
|
|
254
|
+
<span class="ruby-constant">Module</span> <span class="ruby-identifier">dependencies</span>.
|
|
255
|
+
<span class="ruby-operator">/</span>
|
|
256
|
+
|
|
257
|
+
<span class="ruby-identifier">var</span> <span class="ruby-constant">AssertionError</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./error'</span>),
|
|
258
|
+
<span class="ruby-identifier">util</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./utils'</span>),
|
|
259
|
+
<span class="ruby-identifier">flag</span> = <span class="ruby-identifier">util</span>.<span class="ruby-identifier">flag</span>;
|
|
260
|
+
|
|
261
|
+
<span class="ruby-regexp">/*!
|
|
262
|
+
Module export.
|
|
263
|
+
/</span>
|
|
264
|
+
|
|
265
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-constant">Assertion</span>;
|
|
266
|
+
|
|
267
|
+
<span class="ruby-regexp">/*!
|
|
268
|
+
Assertion Constructor
|
|
269
|
+
|
|
270
|
+
Creates object for chaining.
|
|
271
|
+
|
|
272
|
+
@api private
|
|
273
|
+
/</span>
|
|
274
|
+
|
|
275
|
+
<span class="ruby-identifier">function</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>, <span class="ruby-identifier">stack</span>) {
|
|
276
|
+
<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'ssfi'</span>, <span class="ruby-identifier">stack</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">arguments</span>.<span class="ruby-identifier">callee</span>);
|
|
277
|
+
<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>, <span class="ruby-identifier">obj</span>);
|
|
278
|
+
<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
<span class="ruby-node">/*!
|
|
282
|
+
### Assertion.includeStack
|
|
283
|
+
|
|
284
|
+
User configurable property, influences whether stack trace
|
|
285
|
+
is included in Assertion error message. Default of false
|
|
286
|
+
suppresses stack trace in the error message
|
|
287
|
+
|
|
288
|
+
Assertion.includeStack = true; /</span><span class="ruby-operator">/</span> <span class="ruby-identifier">enable</span> <span class="ruby-identifier">stack</span> <span class="ruby-identifier">on</span> <span class="ruby-identifier">error</span>
|
|
289
|
+
|
|
290
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
291
|
+
<span class="ruby-regexp">/
|
|
292
|
+
|
|
293
|
+
Assertion.includeStack = false;
|
|
294
|
+
|
|
295
|
+
/</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
|
|
296
|
+
<span class="ruby-comment">### Assertion.showDiff</span>
|
|
297
|
+
|
|
298
|
+
<span class="ruby-constant">User</span> <span class="ruby-identifier">configurable</span> <span class="ruby-identifier">property</span>, <span class="ruby-identifier">influences</span> <span class="ruby-identifier">whether</span> <span class="ruby-keyword">or</span> <span class="ruby-keyword">not</span>
|
|
299
|
+
<span class="ruby-identifier">the</span> <span class="ruby-value">%xshowDiff`</span> <span class="ruby-identifier">flag</span> <span class="ruby-identifier">should</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">included</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">thrown</span>
|
|
300
|
+
<span class="ruby-constant">AssertionErrors</span>. <span class="ruby-value">%xfalse`</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">always</span> <span class="ruby-identifier">be</span> <span class="ruby-value">%xfalse`</span>; <span class="ruby-value">%xtrue`</span>
|
|
301
|
+
<span class="ruby-identifier">will</span> <span class="ruby-identifier">be</span> <span class="ruby-keyword">true</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">assertion</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">requested</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">diff</span>
|
|
302
|
+
<span class="ruby-identifier">be</span> <span class="ruby-identifier">shown</span>.
|
|
303
|
+
|
|
304
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
305
|
+
<span class="ruby-regexp">/
|
|
306
|
+
|
|
307
|
+
Assertion.showDiff = true;
|
|
308
|
+
|
|
309
|
+
Assertion.addProperty = function(name, fn) {
|
|
310
|
+
util.addProperty(this.prototype, name, fn);
|
|
311
|
+
};
|
|
312
|
+
|
|
313
|
+
Assertion.addMethod = function(name, fn) {
|
|
314
|
+
util.addMethod(this.prototype, name, fn);
|
|
315
|
+
};
|
|
316
|
+
|
|
317
|
+
Assertion.addChainableMethod = function(name, fn, chainingBehavior) {
|
|
318
|
+
util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
|
|
319
|
+
};
|
|
320
|
+
|
|
321
|
+
Assertion.overwriteProperty = function(name, fn) {
|
|
322
|
+
util.overwriteProperty(this.prototype, name, fn);
|
|
323
|
+
};
|
|
324
|
+
|
|
325
|
+
Assertion.overwriteMethod = function(name, fn) {
|
|
326
|
+
util.overwriteMethod(this.prototype, name, fn);
|
|
327
|
+
};
|
|
328
|
+
|
|
329
|
+
/</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
|
|
330
|
+
<span class="ruby-comment">### .assert(expression, message, negateMessage, expected, actual)</span>
|
|
331
|
+
|
|
332
|
+
<span class="ruby-constant">Executes</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">expression</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">check</span> <span class="ruby-identifier">expectations</span>. <span class="ruby-constant">Throws</span> <span class="ruby-constant">AssertionError</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">reporting</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">test</span> <span class="ruby-identifier">doesn</span><span class="ruby-string">'t pass.
|
|
333
|
+
|
|
334
|
+
@name assert
|
|
335
|
+
@param {Philosophical} expression to be tested
|
|
336
|
+
@param {String} message to display if fails
|
|
337
|
+
@param {String} negatedMessage to display if negated expression fails
|
|
338
|
+
@param {Mixed} expected value (remember to check for negation)
|
|
339
|
+
@param {Mixed} actual (optional) will default to `this.obj`
|
|
340
|
+
@api private
|
|
341
|
+
/
|
|
342
|
+
|
|
343
|
+
Assertion.prototype.assert = function(expr, msg, negateMsg, expected, _actual, showDiff) {
|
|
344
|
+
var ok = util.test(this, arguments);
|
|
345
|
+
if (true !== showDiff) showDiff = false;
|
|
346
|
+
if (true !== Assertion.showDiff) showDiff = false;
|
|
347
|
+
|
|
348
|
+
if (!ok) {
|
|
349
|
+
var msg = util.getMessage(this, arguments),
|
|
350
|
+
actual = util.getActual(this, arguments);
|
|
351
|
+
throw new AssertionError({
|
|
352
|
+
message: msg,
|
|
353
|
+
actual: actual,
|
|
354
|
+
expected: expected,
|
|
355
|
+
stackStartFunction: (Assertion.includeStack) ? this.assert : flag(this, '</span><span class="ruby-identifier">ssfi</span><span class="ruby-string">'),
|
|
356
|
+
showDiff: showDiff
|
|
357
|
+
});
|
|
358
|
+
}
|
|
359
|
+
};
|
|
360
|
+
|
|
361
|
+
/*!
|
|
362
|
+
### ._obj
|
|
363
|
+
|
|
364
|
+
Quick reference to stored `actual` value for plugin developers.
|
|
365
|
+
|
|
366
|
+
@api private
|
|
367
|
+
/
|
|
368
|
+
|
|
369
|
+
Object.defineProperty(Assertion.prototype, '</span><span class="ruby-identifier">_obj</span><span class="ruby-string">', {
|
|
370
|
+
get: function() {
|
|
371
|
+
return flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">');
|
|
372
|
+
},
|
|
373
|
+
set: function(val) {
|
|
374
|
+
flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">', val);
|
|
375
|
+
}
|
|
376
|
+
});
|
|
377
|
+
|
|
378
|
+
}); // module: chai/assertion.js
|
|
379
|
+
require.register("chai/core/assertions.js", function(module, exports, require) {
|
|
380
|
+
/*!
|
|
381
|
+
chai
|
|
382
|
+
http://chaijs.com
|
|
383
|
+
Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
|
|
384
|
+
MIT Licensed
|
|
385
|
+
/
|
|
386
|
+
|
|
387
|
+
module.exports = function(chai, _) {
|
|
388
|
+
var Assertion = chai.Assertion,
|
|
389
|
+
toString = Object.prototype.toString,
|
|
390
|
+
flag = _.flag;
|
|
391
|
+
|
|
392
|
+
/**
|
|
393
|
+
### Language Chains
|
|
394
|
+
|
|
395
|
+
The following are provide as chainable getters to
|
|
396
|
+
improve the readability of your assertions. They
|
|
397
|
+
do not provide an testing capability unless they
|
|
398
|
+
have been overwritten by a plugin.
|
|
399
|
+
|
|
400
|
+
**Chains**
|
|
401
|
+
|
|
402
|
+
- to
|
|
403
|
+
- be
|
|
404
|
+
- been
|
|
405
|
+
- is
|
|
406
|
+
- that
|
|
407
|
+
- and
|
|
408
|
+
- have
|
|
409
|
+
- with
|
|
410
|
+
- at
|
|
411
|
+
- of
|
|
412
|
+
|
|
413
|
+
@name language chains
|
|
414
|
+
@api public
|
|
415
|
+
/
|
|
416
|
+
|
|
417
|
+
['</span><span class="ruby-identifier">to</span><span class="ruby-string">', '</span><span class="ruby-identifier">be</span><span class="ruby-string">', '</span><span class="ruby-identifier">been</span><span class="ruby-string">', '</span><span class="ruby-identifier">is</span><span class="ruby-string">', '</span><span class="ruby-keyword">and</span><span class="ruby-string">', '</span><span class="ruby-identifier">have</span><span class="ruby-string">', '</span><span class="ruby-identifier">with</span><span class="ruby-string">', '</span><span class="ruby-identifier">that</span><span class="ruby-string">', '</span><span class="ruby-identifier">at</span><span class="ruby-string">', '</span><span class="ruby-identifier">of</span><span class="ruby-string">'].forEach(function(chain) {
|
|
418
|
+
Assertion.addProperty(chain, function() {
|
|
419
|
+
return this;
|
|
420
|
+
});
|
|
421
|
+
});
|
|
422
|
+
|
|
423
|
+
/**
|
|
424
|
+
### .not
|
|
425
|
+
|
|
426
|
+
Negates any of assertions following in the chain.
|
|
427
|
+
|
|
428
|
+
expect(foo).to.not.equal('</span><span class="ruby-identifier">bar</span><span class="ruby-string">');
|
|
429
|
+
expect(goodFn).to.not.throw(Error);
|
|
430
|
+
expect({ foo: '</span><span class="ruby-identifier">baz</span><span class="ruby-string">' }).to.have.property('</span><span class="ruby-identifier">foo</span><span class="ruby-string">')
|
|
431
|
+
.and.not.equal('</span><span class="ruby-identifier">bar</span><span class="ruby-string">');
|
|
432
|
+
|
|
433
|
+
@name not
|
|
434
|
+
@api public
|
|
435
|
+
/
|
|
436
|
+
|
|
437
|
+
Assertion.addProperty('</span><span class="ruby-keyword">not</span><span class="ruby-string">', function() {
|
|
438
|
+
flag(this, '</span><span class="ruby-identifier">negate</span><span class="ruby-string">', true);
|
|
439
|
+
});
|
|
440
|
+
|
|
441
|
+
/**
|
|
442
|
+
### .deep
|
|
443
|
+
|
|
444
|
+
Sets the `deep` flag, later used by the `equal` and
|
|
445
|
+
`property` assertions.
|
|
446
|
+
|
|
447
|
+
expect(foo).to.deep.equal({ bar: '</span><span class="ruby-identifier">baz</span><span class="ruby-string">' });
|
|
448
|
+
expect({ foo: { bar: { baz: '</span><span class="ruby-identifier">quux</span><span class="ruby-string">' } } })
|
|
449
|
+
.to.have.deep.property('</span><span class="ruby-identifier">foo</span>.<span class="ruby-identifier">bar</span>.<span class="ruby-identifier">baz</span><span class="ruby-string">', '</span><span class="ruby-identifier">quux</span><span class="ruby-string">');
|
|
450
|
+
|
|
451
|
+
@name deep
|
|
452
|
+
@api public
|
|
453
|
+
/
|
|
454
|
+
|
|
455
|
+
Assertion.addProperty('</span><span class="ruby-identifier">deep</span><span class="ruby-string">', function() {
|
|
456
|
+
flag(this, '</span><span class="ruby-identifier">deep</span><span class="ruby-string">', true);
|
|
457
|
+
});
|
|
458
|
+
|
|
459
|
+
/**
|
|
460
|
+
### .a(type)
|
|
461
|
+
|
|
462
|
+
The `a` and `an` assertions are aliases that can be
|
|
463
|
+
used either as language chains or to assert a value'</span><span class="ruby-identifier">s</span>
|
|
464
|
+
<span class="ruby-identifier">type</span>.
|
|
465
|
+
|
|
466
|
+
<span class="ruby-operator">/</span><span class="ruby-regexp">/ typeof
|
|
467
|
+
expect('test').to.be.a('string');
|
|
468
|
+
expect({ foo: 'bar' }).to.be.an('object');
|
|
469
|
+
expect(null).to.be.a('null');
|
|
470
|
+
expect(undefined).to.be.an('undefined');
|
|
471
|
+
|
|
472
|
+
/</span><span class="ruby-operator">/</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chain</span>
|
|
473
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">foo</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>.<span class="ruby-identifier">instanceof</span>(<span class="ruby-constant">Foo</span>);
|
|
474
|
+
|
|
475
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">a</span>
|
|
476
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">an</span>
|
|
477
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">type</span>
|
|
478
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
479
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
480
|
+
<span class="ruby-node">/
|
|
481
|
+
|
|
482
|
+
function an(type, msg) {
|
|
483
|
+
if (msg) flag(this, 'message', msg);
|
|
484
|
+
type = type.toLowerCase();
|
|
485
|
+
var obj = flag(this, 'object'),
|
|
486
|
+
article = ~ ['a', 'e', 'i', 'o', 'u'].indexOf(type.charAt(0)) ? 'an ' : 'a ';
|
|
487
|
+
|
|
488
|
+
this.assert(
|
|
489
|
+
type === _.type(obj), 'expected #{this} to be ' + article + type, 'expected #{this} not to be ' + article + type);
|
|
490
|
+
}
|
|
491
|
+
|
|
492
|
+
Assertion.addChainableMethod('an', an);
|
|
493
|
+
Assertion.addChainableMethod('a', an);
|
|
494
|
+
|
|
495
|
+
/</span><span class="ruby-operator">**</span>
|
|
496
|
+
<span class="ruby-comment">### .include(value)</span>
|
|
497
|
+
|
|
498
|
+
<span class="ruby-constant">The</span> <span class="ruby-value">%xinclude`</span> <span class="ruby-keyword">and</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">assertions</span> <span class="ruby-identifier">can</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">either</span> <span class="ruby-identifier">property</span>
|
|
499
|
+
<span class="ruby-identifier">based</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chains</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">methods</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">assert</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">inclusion</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">object</span>
|
|
500
|
+
<span class="ruby-keyword">in</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">array</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">substring</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">string</span>. <span class="ruby-constant">When</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chains</span>,
|
|
501
|
+
<span class="ruby-identifier">they</span> <span class="ruby-identifier">toggle</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">flag</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xkeys`</span> <span class="ruby-identifier">assertion</span>.
|
|
502
|
+
|
|
503
|
+
<span class="ruby-identifier">expect</span>([<span class="ruby-value">1</span>,<span class="ruby-value">2</span>,<span class="ruby-value">3</span>]).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">include</span>(<span class="ruby-value">2</span>);
|
|
504
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-string">'foobar'</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">contain</span>(<span class="ruby-string">'foo'</span>);
|
|
505
|
+
<span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-string">'bar'</span>, <span class="ruby-identifier">hello</span><span class="ruby-operator">:</span> <span class="ruby-string">'universe'</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">include</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-string">'foo'</span>);
|
|
506
|
+
|
|
507
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">include</span>
|
|
508
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">contain</span>
|
|
509
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">Object</span><span class="ruby-operator">|</span><span class="ruby-constant">String</span><span class="ruby-operator">|</span><span class="ruby-constant">Number</span>} <span class="ruby-identifier">obj</span>
|
|
510
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
511
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
512
|
+
<span class="ruby-node">/
|
|
513
|
+
|
|
514
|
+
function includeChainingBehavior() {
|
|
515
|
+
flag(this, 'contains', true);
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
function include(val, msg) {
|
|
519
|
+
if (msg) flag(this, 'message', msg);
|
|
520
|
+
var obj = flag(this, 'object')
|
|
521
|
+
this.assert(~obj.indexOf(val), 'expected #{this} to include ' + _.inspect(val), 'expected #{this} to not include ' + _.inspect(val));
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
Assertion.addChainableMethod('include', include, includeChainingBehavior);
|
|
525
|
+
Assertion.addChainableMethod('contain', include, includeChainingBehavior);
|
|
526
|
+
|
|
527
|
+
/</span><span class="ruby-operator">**</span>
|
|
528
|
+
<span class="ruby-comment">### .ok</span>
|
|
529
|
+
|
|
530
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">truthy</span>.
|
|
531
|
+
|
|
532
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-string">'everthing'</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
|
|
533
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
|
|
534
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-keyword">false</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
|
|
535
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
|
|
536
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
|
|
537
|
+
|
|
538
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">ok</span>
|
|
539
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
540
|
+
<span class="ruby-node">/
|
|
541
|
+
|
|
542
|
+
Assertion.addProperty('ok', function() {
|
|
543
|
+
this.assert(
|
|
544
|
+
flag(this, 'object'), 'expected #{this} to be truthy', 'expected #{this} to be falsy');
|
|
545
|
+
});
|
|
546
|
+
|
|
547
|
+
/</span><span class="ruby-operator">**</span>
|
|
548
|
+
<span class="ruby-comment">### .true</span>
|
|
549
|
+
|
|
550
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xtrue`</span>.
|
|
551
|
+
|
|
552
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-keyword">true</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">true</span>;
|
|
553
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">true</span>;
|
|
554
|
+
|
|
555
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-keyword">true</span>
|
|
556
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
557
|
+
<span class="ruby-node">/
|
|
558
|
+
|
|
559
|
+
Assertion.addProperty('true', function() {
|
|
560
|
+
this.assert(
|
|
561
|
+
true === flag(this, 'object'), 'expected #{this} to be true', 'expected #{this} to be false', this.negate ? false : true);
|
|
562
|
+
});
|
|
563
|
+
|
|
564
|
+
/</span><span class="ruby-operator">**</span>
|
|
565
|
+
<span class="ruby-comment">### .false</span>
|
|
566
|
+
|
|
567
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xfalse`</span>.
|
|
568
|
+
|
|
569
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-keyword">false</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">false</span>;
|
|
570
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-value">0</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">false</span>;
|
|
571
|
+
|
|
572
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-keyword">false</span>
|
|
573
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
574
|
+
<span class="ruby-node">/
|
|
575
|
+
|
|
576
|
+
Assertion.addProperty('false', function() {
|
|
577
|
+
this.assert(
|
|
578
|
+
false === flag(this, 'object'), 'expected #{this} to be false', 'expected #{this} to be true', this.negate ? true : false);
|
|
579
|
+
});
|
|
580
|
+
|
|
581
|
+
/</span><span class="ruby-operator">**</span>
|
|
582
|
+
<span class="ruby-comment">### .null</span>
|
|
583
|
+
|
|
584
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xnull`</span>.
|
|
585
|
+
|
|
586
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">null</span>;
|
|
587
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">not</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">null</span>;
|
|
588
|
+
|
|
589
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">null</span>
|
|
590
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
591
|
+
<span class="ruby-node">/
|
|
592
|
+
|
|
593
|
+
Assertion.addProperty('null', function() {
|
|
594
|
+
this.assert(
|
|
595
|
+
null === flag(this, 'object'), 'expected #{this} to be null', 'expected #{this} not to be null');
|
|
596
|
+
});
|
|
597
|
+
|
|
598
|
+
/</span><span class="ruby-operator">**</span>
|
|
599
|
+
<span class="ruby-comment">### .undefined</span>
|
|
600
|
+
|
|
601
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xundefined`</span>.
|
|
602
|
+
|
|
603
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">undefined</span>;
|
|
604
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">undefined</span>;
|
|
605
|
+
|
|
606
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">undefined</span>
|
|
607
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
608
|
+
<span class="ruby-node">/
|
|
609
|
+
|
|
610
|
+
Assertion.addProperty('undefined', function() {
|
|
611
|
+
this.assert(
|
|
612
|
+
undefined === flag(this, 'object'), 'expected #{this} to be undefined', 'expected #{this} not to be undefined');
|
|
613
|
+
});
|
|
614
|
+
|
|
615
|
+
/</span><span class="ruby-operator">**</span>
|
|
616
|
+
<span class="ruby-comment">### .exist</span>
|
|
617
|
+
|
|
618
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">neither</span> <span class="ruby-value">%xnull`</span> <span class="ruby-identifier">nor</span> <span class="ruby-value">%xundefined`</span>.
|
|
619
|
+
|
|
620
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">foo</span> = <span class="ruby-string">'hi'</span>
|
|
621
|
+
, <span class="ruby-identifier">bar</span> = <span class="ruby-identifier">null</span>
|
|
622
|
+
, <span class="ruby-identifier">baz</span>;
|
|
623
|
+
|
|
624
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">foo</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">exist</span>;
|
|
625
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">bar</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">exist</span>;
|
|
626
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">baz</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">exist</span>;
|
|
627
|
+
|
|
628
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">exist</span>
|
|
629
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
630
|
+
<span class="ruby-node">/
|
|
631
|
+
|
|
632
|
+
Assertion.addProperty('exist', function() {
|
|
633
|
+
this.assert(
|
|
634
|
+
null != flag(this, 'object'), 'expected #{this} to exist', 'expected #{this} to not exist');
|
|
635
|
+
});
|
|
636
|
+
|
|
637
|
+
/</span><span class="ruby-operator">**</span>
|
|
638
|
+
<span class="ruby-comment">### .empty</span>
|
|
639
|
+
|
|
640
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span><span class="ruby-string">'s length is `0`. For arrays, it checks
|
|
641
|
+
the `length` property. For objects, it gets the count of
|
|
642
|
+
enumerable keys.
|
|
643
|
+
|
|
644
|
+
expect([]).to.be.empty;
|
|
645
|
+
expect('</span><span class="ruby-string">').to.be.empty;
|
|
646
|
+
expect({}).to.be.empty;
|
|
647
|
+
|
|
648
|
+
@name empty
|
|
649
|
+
@api public
|
|
650
|
+
/
|
|
651
|
+
|
|
652
|
+
Assertion.addProperty('</span><span class="ruby-identifier">empty</span><span class="ruby-string">', function() {
|
|
653
|
+
var obj = flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">'),
|
|
654
|
+
expected = obj;
|
|
655
|
+
|
|
656
|
+
if (Array.isArray(obj) || '</span><span class="ruby-identifier">string</span><span class="ruby-string">' === typeof object) {
|
|
657
|
+
expected = obj.length;
|
|
658
|
+
} else if (typeof obj === '</span><span class="ruby-identifier">object</span><span class="ruby-string">') {
|
|
659
|
+
expected = Object.keys(obj).length;
|
|
660
|
+
}
|
|
661
|
+
|
|
662
|
+
this.assert(!expected, '</span><span class="ruby-identifier">expected</span> <span class="ruby-comment">#{this} to be empty', 'expected #{this} not to be empty');</span>
|
|
663
|
+
});
|
|
664
|
+
|
|
665
|
+
<span class="ruby-node">/**
|
|
666
|
+
### .arguments
|
|
667
|
+
|
|
668
|
+
Asserts that the target is an arguments object.
|
|
669
|
+
|
|
670
|
+
function test () {
|
|
671
|
+
expect(arguments).to.be.arguments;
|
|
672
|
+
}
|
|
673
|
+
|
|
674
|
+
@name arguments
|
|
675
|
+
@alias Arguments
|
|
676
|
+
@api public
|
|
677
|
+
/</span>
|
|
678
|
+
|
|
679
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">checkArguments</span>() {
|
|
680
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>),
|
|
681
|
+
<span class="ruby-identifier">type</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
|
|
682
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(<span class="ruby-string">'[object Arguments]'</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">type</span>, <span class="ruby-string">'expected #{this} to be arguments but got '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">type</span>, <span class="ruby-string">'expected #{this} to not be arguments'</span>);
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addProperty</span>(<span class="ruby-string">'arguments'</span>, <span class="ruby-identifier">checkArguments</span>);
|
|
686
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addProperty</span>(<span class="ruby-string">'Arguments'</span>, <span class="ruby-identifier">checkArguments</span>);
|
|
687
|
+
|
|
688
|
+
<span class="ruby-node">/**
|
|
689
|
+
### .equal(value)
|
|
690
|
+
|
|
691
|
+
Asserts that the target is strictly equal (`===`) to `value`.
|
|
692
|
+
Alternately, if the `deep` flag is set, asserts that
|
|
693
|
+
the target is deeply equal to `value`.
|
|
694
|
+
|
|
695
|
+
expect('hello').to.equal('hello');
|
|
696
|
+
expect(42).to.equal(42);
|
|
697
|
+
expect(1).to.not.equal(true);
|
|
698
|
+
expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
|
|
699
|
+
expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
|
|
700
|
+
|
|
701
|
+
@name equal
|
|
702
|
+
@alias equals
|
|
703
|
+
@alias eq
|
|
704
|
+
@alias deep.equal
|
|
705
|
+
@param {Mixed} value
|
|
706
|
+
@param {String} message _optional_
|
|
707
|
+
@api public
|
|
708
|
+
/</span>
|
|
709
|
+
|
|
710
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertEqual</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
711
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
712
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
713
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'deep'</span>)) {
|
|
714
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">val</span>);
|
|
715
|
+
} <span class="ruby-keyword">else</span> {
|
|
716
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
717
|
+
<span class="ruby-identifier">val</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">obj</span>, <span class="ruby-string">'expected #{this} to equal #{exp}'</span>, <span class="ruby-string">'expected #{this} to not equal #{exp}'</span>, <span class="ruby-identifier">val</span>, <span class="ruby-identifier">this</span>.<span class="ruby-identifier">_obj</span>, <span class="ruby-keyword">true</span>);
|
|
718
|
+
}
|
|
719
|
+
}
|
|
720
|
+
|
|
721
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'equal'</span>, <span class="ruby-identifier">assertEqual</span>);
|
|
722
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'equals'</span>, <span class="ruby-identifier">assertEqual</span>);
|
|
723
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'eq'</span>, <span class="ruby-identifier">assertEqual</span>);
|
|
724
|
+
|
|
725
|
+
<span class="ruby-node">/**
|
|
726
|
+
### .eql(value)
|
|
727
|
+
|
|
728
|
+
Asserts that the target is deeply equal to `value`.
|
|
729
|
+
|
|
730
|
+
expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
|
|
731
|
+
expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
|
|
732
|
+
|
|
733
|
+
@name eql
|
|
734
|
+
@alias eqls
|
|
735
|
+
@param {Mixed} value
|
|
736
|
+
@param {String} message _optional_
|
|
737
|
+
@api public
|
|
738
|
+
/</span>
|
|
739
|
+
|
|
740
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertEql</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>) {
|
|
741
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
742
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
743
|
+
<span class="ruby-identifier">_</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>)), <span class="ruby-string">'expected #{this} to deeply equal #{exp}'</span>, <span class="ruby-string">'expected #{this} to not deeply equal #{exp}'</span>, <span class="ruby-identifier">obj</span>, <span class="ruby-identifier">this</span>.<span class="ruby-identifier">_obj</span>, <span class="ruby-keyword">true</span>);
|
|
744
|
+
}
|
|
745
|
+
|
|
746
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'eql'</span>, <span class="ruby-identifier">assertEql</span>);
|
|
747
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'eqls'</span>, <span class="ruby-identifier">assertEql</span>);
|
|
748
|
+
|
|
749
|
+
<span class="ruby-node">/**
|
|
750
|
+
### .above(value)
|
|
751
|
+
|
|
752
|
+
Asserts that the target is greater than `value`.
|
|
753
|
+
|
|
754
|
+
expect(10).to.be.above(5);
|
|
755
|
+
|
|
756
|
+
Can also be used in conjunction with `length` to
|
|
757
|
+
assert a minimum length. The benefit being a
|
|
758
|
+
more informative error message than if the length
|
|
759
|
+
was supplied directly.
|
|
760
|
+
|
|
761
|
+
expect('foo').to.have.length.above(2);
|
|
762
|
+
expect([ 1, 2, 3 ]).to.have.length.above(2);
|
|
763
|
+
|
|
764
|
+
@name above
|
|
765
|
+
@alias gt
|
|
766
|
+
@alias greaterThan
|
|
767
|
+
@param {Number} value
|
|
768
|
+
@param {String} message _optional_
|
|
769
|
+
@api public
|
|
770
|
+
/</span>
|
|
771
|
+
|
|
772
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertAbove</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
|
|
773
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
774
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
775
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'doLength'</span>)) {
|
|
776
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'length'</span>);
|
|
777
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
|
|
778
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
779
|
+
<span class="ruby-identifier">len</span> <span class="ruby-operator">></span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to have a length above #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to not have a length above #{exp}'</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
|
|
780
|
+
} <span class="ruby-keyword">else</span> {
|
|
781
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
782
|
+
<span class="ruby-identifier">obj</span> <span class="ruby-operator">></span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be above '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be at most '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
|
|
783
|
+
}
|
|
784
|
+
}
|
|
785
|
+
|
|
786
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'above'</span>, <span class="ruby-identifier">assertAbove</span>);
|
|
787
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'gt'</span>, <span class="ruby-identifier">assertAbove</span>);
|
|
788
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'greaterThan'</span>, <span class="ruby-identifier">assertAbove</span>);
|
|
789
|
+
|
|
790
|
+
<span class="ruby-node">/**
|
|
791
|
+
### .least(value)
|
|
792
|
+
|
|
793
|
+
Asserts that the target is greater than or equal to `value`.
|
|
794
|
+
|
|
795
|
+
expect(10).to.be.at.least(10);
|
|
796
|
+
|
|
797
|
+
Can also be used in conjunction with `length` to
|
|
798
|
+
assert a minimum length. The benefit being a
|
|
799
|
+
more informative error message than if the length
|
|
800
|
+
was supplied directly.
|
|
801
|
+
|
|
802
|
+
expect('foo').to.have.length.of.at.least(2);
|
|
803
|
+
expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
|
|
804
|
+
|
|
805
|
+
@name least
|
|
806
|
+
@alias gte
|
|
807
|
+
@param {Number} value
|
|
808
|
+
@param {String} message _optional_
|
|
809
|
+
@api public
|
|
810
|
+
/</span>
|
|
811
|
+
|
|
812
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertLeast</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
|
|
813
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
814
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
815
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'doLength'</span>)) {
|
|
816
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'length'</span>);
|
|
817
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
|
|
818
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
819
|
+
<span class="ruby-identifier">len</span> <span class="ruby-operator">>=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to have a length at least #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to have a length below #{exp}'</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
|
|
820
|
+
} <span class="ruby-keyword">else</span> {
|
|
821
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
822
|
+
<span class="ruby-identifier">obj</span> <span class="ruby-operator">>=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be at least '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be below '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
|
|
823
|
+
}
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'least'</span>, <span class="ruby-identifier">assertLeast</span>);
|
|
827
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'gte'</span>, <span class="ruby-identifier">assertLeast</span>);
|
|
828
|
+
|
|
829
|
+
<span class="ruby-node">/**
|
|
830
|
+
### .below(value)
|
|
831
|
+
|
|
832
|
+
Asserts that the target is less than `value`.
|
|
833
|
+
|
|
834
|
+
expect(5).to.be.below(10);
|
|
835
|
+
|
|
836
|
+
Can also be used in conjunction with `length` to
|
|
837
|
+
assert a maximum length. The benefit being a
|
|
838
|
+
more informative error message than if the length
|
|
839
|
+
was supplied directly.
|
|
840
|
+
|
|
841
|
+
expect('foo').to.have.length.below(4);
|
|
842
|
+
expect([ 1, 2, 3 ]).to.have.length.below(4);
|
|
843
|
+
|
|
844
|
+
@name below
|
|
845
|
+
@alias lt
|
|
846
|
+
@alias lessThan
|
|
847
|
+
@param {Number} value
|
|
848
|
+
@param {String} message _optional_
|
|
849
|
+
@api public
|
|
850
|
+
/</span>
|
|
851
|
+
|
|
852
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertBelow</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
|
|
853
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
854
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
855
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'doLength'</span>)) {
|
|
856
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'length'</span>);
|
|
857
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
|
|
858
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
859
|
+
<span class="ruby-identifier">len</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to have a length below #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to not have a length below #{exp}'</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
|
|
860
|
+
} <span class="ruby-keyword">else</span> {
|
|
861
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
862
|
+
<span class="ruby-identifier">obj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be below '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be at least '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
|
|
863
|
+
}
|
|
864
|
+
}
|
|
865
|
+
|
|
866
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'below'</span>, <span class="ruby-identifier">assertBelow</span>);
|
|
867
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'lt'</span>, <span class="ruby-identifier">assertBelow</span>);
|
|
868
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'lessThan'</span>, <span class="ruby-identifier">assertBelow</span>);
|
|
869
|
+
|
|
870
|
+
<span class="ruby-node">/**
|
|
871
|
+
### .most(value)
|
|
872
|
+
|
|
873
|
+
Asserts that the target is less than or equal to `value`.
|
|
874
|
+
|
|
875
|
+
expect(5).to.be.at.most(5);
|
|
876
|
+
|
|
877
|
+
Can also be used in conjunction with `length` to
|
|
878
|
+
assert a maximum length. The benefit being a
|
|
879
|
+
more informative error message than if the length
|
|
880
|
+
was supplied directly.
|
|
881
|
+
|
|
882
|
+
expect('foo').to.have.length.of.at.most(4);
|
|
883
|
+
expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
|
|
884
|
+
|
|
885
|
+
@name most
|
|
886
|
+
@alias lte
|
|
887
|
+
@param {Number} value
|
|
888
|
+
@param {String} message _optional_
|
|
889
|
+
@api public
|
|
890
|
+
/</span>
|
|
891
|
+
|
|
892
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertMost</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
|
|
893
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
894
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
895
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'doLength'</span>)) {
|
|
896
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'length'</span>);
|
|
897
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
|
|
898
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
899
|
+
<span class="ruby-identifier">len</span> <span class="ruby-operator"><=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to have a length at most #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to have a length above #{exp}'</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
|
|
900
|
+
} <span class="ruby-keyword">else</span> {
|
|
901
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
902
|
+
<span class="ruby-identifier">obj</span> <span class="ruby-operator"><=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be at most '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">'expected #{this} to be above '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
|
|
903
|
+
}
|
|
904
|
+
}
|
|
905
|
+
|
|
906
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'most'</span>, <span class="ruby-identifier">assertMost</span>);
|
|
907
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'lte'</span>, <span class="ruby-identifier">assertMost</span>);
|
|
908
|
+
|
|
909
|
+
<span class="ruby-node">/**
|
|
910
|
+
### .within(start, finish)
|
|
911
|
+
|
|
912
|
+
Asserts that the target is within a range.
|
|
913
|
+
|
|
914
|
+
expect(7).to.be.within(5,10);
|
|
915
|
+
|
|
916
|
+
Can also be used in conjunction with `length` to
|
|
917
|
+
assert a length range. The benefit being a
|
|
918
|
+
more informative error message than if the length
|
|
919
|
+
was supplied directly.
|
|
920
|
+
|
|
921
|
+
expect('foo').to.have.length.within(2,4);
|
|
922
|
+
expect([ 1, 2, 3 ]).to.have.length.within(2,4);
|
|
923
|
+
|
|
924
|
+
@name within
|
|
925
|
+
@param {Number} start lowerbound inclusive
|
|
926
|
+
@param {Number} finish upperbound inclusive
|
|
927
|
+
@param {String} message _optional_
|
|
928
|
+
@api public
|
|
929
|
+
/</span>
|
|
930
|
+
|
|
931
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'within'</span>, <span class="ruby-identifier">function</span>(<span class="ruby-identifier">start</span>, <span class="ruby-identifier">finish</span>, <span class="ruby-identifier">msg</span>) {
|
|
932
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
933
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>),
|
|
934
|
+
<span class="ruby-identifier">range</span> = <span class="ruby-identifier">start</span> <span class="ruby-operator">+</span> <span class="ruby-string">'..'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">finish</span>;
|
|
935
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'doLength'</span>)) {
|
|
936
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'length'</span>);
|
|
937
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
|
|
938
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
939
|
+
<span class="ruby-identifier">len</span> <span class="ruby-operator">>=</span> <span class="ruby-identifier">start</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">len</span> <span class="ruby-operator"><=</span> <span class="ruby-identifier">finish</span>, <span class="ruby-string">'expected #{this} to have a length within '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>, <span class="ruby-string">'expected #{this} to not have a length within '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>);
|
|
940
|
+
} <span class="ruby-keyword">else</span> {
|
|
941
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
942
|
+
<span class="ruby-identifier">obj</span> <span class="ruby-operator">>=</span> <span class="ruby-identifier">start</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">obj</span> <span class="ruby-operator"><=</span> <span class="ruby-identifier">finish</span>, <span class="ruby-string">'expected #{this} to be within '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>, <span class="ruby-string">'expected #{this} to not be within '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>);
|
|
943
|
+
}
|
|
944
|
+
});
|
|
945
|
+
|
|
946
|
+
<span class="ruby-node">/**
|
|
947
|
+
### .instanceof(constructor)
|
|
948
|
+
|
|
949
|
+
Asserts that the target is an instance of `constructor`.
|
|
950
|
+
|
|
951
|
+
var Tea = function (name) { this.name = name; }
|
|
952
|
+
, Chai = new Tea('chai');
|
|
953
|
+
|
|
954
|
+
expect(Chai).to.be.an.instanceof(Tea);
|
|
955
|
+
expect([ 1, 2, 3 ]).to.be.instanceof(Array);
|
|
956
|
+
|
|
957
|
+
@name instanceof
|
|
958
|
+
@param {Constructor} constructor
|
|
959
|
+
@param {String} message _optional_
|
|
960
|
+
@alias instanceOf
|
|
961
|
+
@api public
|
|
962
|
+
/</span>
|
|
963
|
+
|
|
964
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">assertInstanceOf</span>(<span class="ruby-identifier">constructor</span>, <span class="ruby-identifier">msg</span>) {
|
|
965
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
966
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">name</span> = <span class="ruby-identifier">_</span>.<span class="ruby-identifier">getName</span>(<span class="ruby-identifier">constructor</span>);
|
|
967
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
968
|
+
<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>) <span class="ruby-identifier">instanceof</span> <span class="ruby-identifier">constructor</span>, <span class="ruby-string">'expected #{this} to be an instance of '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">name</span>, <span class="ruby-string">'expected #{this} to not be an instance of '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">name</span>);
|
|
969
|
+
};
|
|
970
|
+
|
|
971
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'instanceof'</span>, <span class="ruby-identifier">assertInstanceOf</span>);
|
|
972
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'instanceOf'</span>, <span class="ruby-identifier">assertInstanceOf</span>);
|
|
973
|
+
|
|
974
|
+
<span class="ruby-node">/**
|
|
975
|
+
### .property(name, [value])
|
|
976
|
+
|
|
977
|
+
Asserts that the target has a property `name`, optionally asserting that
|
|
978
|
+
the value of that property is strictly equal to `value`.
|
|
979
|
+
If the `deep` flag is set, you can use dot- and bracket-notation for deep
|
|
980
|
+
references into objects and arrays.
|
|
981
|
+
|
|
982
|
+
/</span><span class="ruby-operator">/</span> <span class="ruby-identifier">simple</span> <span class="ruby-identifier">referencing</span>
|
|
983
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = { <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-string">'bar'</span> };
|
|
984
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'foo'</span>);
|
|
985
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'foo'</span>, <span class="ruby-string">'bar'</span>);
|
|
986
|
+
|
|
987
|
+
<span class="ruby-regexp">//</span> <span class="ruby-identifier">deep</span> <span class="ruby-identifier">referencing</span>
|
|
988
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">deepObj</span> = {
|
|
989
|
+
<span class="ruby-identifier">green</span><span class="ruby-operator">:</span> { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'matcha'</span> }
|
|
990
|
+
, <span class="ruby-identifier">teas</span><span class="ruby-operator">:</span> [ <span class="ruby-string">'chai'</span>, <span class="ruby-string">'matcha'</span>, { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'konacha'</span> } ]
|
|
991
|
+
};
|
|
992
|
+
|
|
993
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'green.tea'</span>, <span class="ruby-string">'matcha'</span>);
|
|
994
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'teas[1]'</span>, <span class="ruby-string">'matcha'</span>);
|
|
995
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'teas[2].tea'</span>, <span class="ruby-string">'konacha'</span>);
|
|
996
|
+
|
|
997
|
+
<span class="ruby-constant">You</span> <span class="ruby-identifier">can</span> <span class="ruby-identifier">also</span> <span class="ruby-identifier">use</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">array</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">starting</span> <span class="ruby-identifier">point</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">a</span> <span class="ruby-value">%xdeep.property`</span>
|
|
998
|
+
<span class="ruby-identifier">assertion</span>, <span class="ruby-keyword">or</span> <span class="ruby-identifier">traverse</span> <span class="ruby-identifier">nested</span> <span class="ruby-identifier">arrays</span>.
|
|
999
|
+
|
|
1000
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">arr</span> = [
|
|
1001
|
+
[ <span class="ruby-string">'chai'</span>, <span class="ruby-string">'matcha'</span>, <span class="ruby-string">'konacha'</span> ]
|
|
1002
|
+
, [ { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'chai'</span> }
|
|
1003
|
+
, { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'matcha'</span> }
|
|
1004
|
+
, { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'konacha'</span> } ]
|
|
1005
|
+
];
|
|
1006
|
+
|
|
1007
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">arr</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'[0][1]'</span>, <span class="ruby-string">'matcha'</span>);
|
|
1008
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">arr</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'[1][2].tea'</span>, <span class="ruby-string">'konacha'</span>);
|
|
1009
|
+
|
|
1010
|
+
<span class="ruby-constant">Furthermore</span>, <span class="ruby-value">%xproperty`</span> <span class="ruby-identifier">changes</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">subject</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">assertion</span>
|
|
1011
|
+
<span class="ruby-identifier">to</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">value</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">property</span> <span class="ruby-identifier">from</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">original</span> <span class="ruby-identifier">object</span>. <span class="ruby-constant">This</span>
|
|
1012
|
+
<span class="ruby-identifier">permits</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">further</span> <span class="ruby-identifier">chainable</span> <span class="ruby-identifier">assertions</span> <span class="ruby-identifier">on</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">property</span>.
|
|
1013
|
+
|
|
1014
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'foo'</span>)
|
|
1015
|
+
.<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'string'</span>);
|
|
1016
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'green'</span>)
|
|
1017
|
+
.<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">'object'</span>)
|
|
1018
|
+
.<span class="ruby-identifier">that</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">equals</span>({ <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'matcha'</span> });
|
|
1019
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'teas'</span>)
|
|
1020
|
+
.<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">'array'</span>)
|
|
1021
|
+
.<span class="ruby-identifier">with</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">'[2]'</span>)
|
|
1022
|
+
.<span class="ruby-identifier">that</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">equals</span>({ <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">'konacha'</span> });
|
|
1023
|
+
|
|
1024
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">property</span>
|
|
1025
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>
|
|
1026
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
|
|
1027
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">Mixed</span>} <span class="ruby-identifier">value</span> (<span class="ruby-identifier">optional</span>)
|
|
1028
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1029
|
+
<span class="ruby-ivar">@returns</span> <span class="ruby-identifier">value</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">property</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">chaining</span>
|
|
1030
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1031
|
+
<span class="ruby-node">/
|
|
1032
|
+
|
|
1033
|
+
Assertion.addMethod('property', function(name, val, msg) {
|
|
1034
|
+
if (msg) flag(this, 'message', msg);
|
|
1035
|
+
|
|
1036
|
+
var descriptor = flag(this, 'deep') ? 'deep property ' : 'property ',
|
|
1037
|
+
negate = flag(this, 'negate'),
|
|
1038
|
+
obj = flag(this, 'object'),
|
|
1039
|
+
value = flag(this, 'deep') ? _.getPathValue(name, obj) : obj[name];
|
|
1040
|
+
|
|
1041
|
+
if (negate && undefined !== val) {
|
|
1042
|
+
if (undefined === value) {
|
|
1043
|
+
msg = (msg != null) ? msg + ': ' : '';
|
|
1044
|
+
throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));
|
|
1045
|
+
}
|
|
1046
|
+
} else {
|
|
1047
|
+
this.assert(
|
|
1048
|
+
undefined !== value, 'expected #{this} to have a ' + descriptor + _.inspect(name), 'expected #{this} to not have ' + descriptor + _.inspect(name));
|
|
1049
|
+
}
|
|
1050
|
+
|
|
1051
|
+
if (undefined !== val) {
|
|
1052
|
+
this.assert(
|
|
1053
|
+
val === value, 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}', 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}', val, value);
|
|
1054
|
+
}
|
|
1055
|
+
|
|
1056
|
+
flag(this, 'object', value);
|
|
1057
|
+
});
|
|
1058
|
+
|
|
1059
|
+
/</span><span class="ruby-operator">**</span>
|
|
1060
|
+
<span class="ruby-comment">### .ownProperty(name)</span>
|
|
1061
|
+
|
|
1062
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">own</span> <span class="ruby-identifier">property</span> <span class="ruby-value">%xname`</span>.
|
|
1063
|
+
|
|
1064
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-string">'test'</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">ownProperty</span>(<span class="ruby-string">'length'</span>);
|
|
1065
|
+
|
|
1066
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">ownProperty</span>
|
|
1067
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">haveOwnProperty</span>
|
|
1068
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
|
|
1069
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1070
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1071
|
+
<span class="ruby-node">/
|
|
1072
|
+
|
|
1073
|
+
function assertOwnProperty(name, msg) {
|
|
1074
|
+
if (msg) flag(this, 'message', msg);
|
|
1075
|
+
var obj = flag(this, 'object');
|
|
1076
|
+
this.assert(
|
|
1077
|
+
obj.hasOwnProperty(name), 'expected #{this} to have own property ' + _.inspect(name), 'expected #{this} to not have own property ' + _.inspect(name));
|
|
1078
|
+
}
|
|
1079
|
+
|
|
1080
|
+
Assertion.addMethod('ownProperty', assertOwnProperty);
|
|
1081
|
+
Assertion.addMethod('haveOwnProperty', assertOwnProperty);
|
|
1082
|
+
|
|
1083
|
+
/</span><span class="ruby-operator">**</span>
|
|
1084
|
+
<span class="ruby-comment">### .length(value)</span>
|
|
1085
|
+
|
|
1086
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span><span class="ruby-string">'s `length` property has
|
|
1087
|
+
the expected value.
|
|
1088
|
+
|
|
1089
|
+
expect([ 1, 2, 3]).to.have.length(3);
|
|
1090
|
+
expect('</span><span class="ruby-identifier">foobar</span><span class="ruby-string">').to.have.length(6);
|
|
1091
|
+
|
|
1092
|
+
Can also be used as a chain precursor to a value
|
|
1093
|
+
comparison for the length property.
|
|
1094
|
+
|
|
1095
|
+
expect('</span><span class="ruby-identifier">foo</span><span class="ruby-string">').to.have.length.above(2);
|
|
1096
|
+
expect([ 1, 2, 3 ]).to.have.length.above(2);
|
|
1097
|
+
expect('</span><span class="ruby-identifier">foo</span><span class="ruby-string">').to.have.length.below(4);
|
|
1098
|
+
expect([ 1, 2, 3 ]).to.have.length.below(4);
|
|
1099
|
+
expect('</span><span class="ruby-identifier">foo</span><span class="ruby-string">').to.have.length.within(2,4);
|
|
1100
|
+
expect([ 1, 2, 3 ]).to.have.length.within(2,4);
|
|
1101
|
+
|
|
1102
|
+
@name length
|
|
1103
|
+
@alias lengthOf
|
|
1104
|
+
@param {Number} length
|
|
1105
|
+
@param {String} message _optional_
|
|
1106
|
+
@api public
|
|
1107
|
+
/
|
|
1108
|
+
|
|
1109
|
+
function assertLengthChain() {
|
|
1110
|
+
flag(this, '</span><span class="ruby-identifier">doLength</span><span class="ruby-string">', true);
|
|
1111
|
+
}
|
|
1112
|
+
|
|
1113
|
+
function assertLength(n, msg) {
|
|
1114
|
+
if (msg) flag(this, '</span><span class="ruby-identifier">message</span><span class="ruby-string">', msg);
|
|
1115
|
+
var obj = flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">');
|
|
1116
|
+
new Assertion(obj, msg).to.have.property('</span><span class="ruby-identifier">length</span><span class="ruby-string">');
|
|
1117
|
+
var len = obj.length;
|
|
1118
|
+
|
|
1119
|
+
this.assert(
|
|
1120
|
+
len == n, '</span><span class="ruby-identifier">expected</span> <span class="ruby-comment">#{this} to have a length of #{exp} but got #{act}', 'expected #{this} to not have a length of #{act}', n, len);</span>
|
|
1121
|
+
}
|
|
1122
|
+
|
|
1123
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addChainableMethod</span>(<span class="ruby-string">'length'</span>, <span class="ruby-identifier">assertLength</span>, <span class="ruby-identifier">assertLengthChain</span>);
|
|
1124
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'lengthOf'</span>, <span class="ruby-identifier">assertLength</span>, <span class="ruby-identifier">assertLengthChain</span>);
|
|
1125
|
+
|
|
1126
|
+
<span class="ruby-node">/**
|
|
1127
|
+
### .match(regexp)
|
|
1128
|
+
|
|
1129
|
+
Asserts that the target matches a regular expression.
|
|
1130
|
+
|
|
1131
|
+
expect('foobar').to.match(/</span><span class="ruby-operator">^</span><span class="ruby-identifier">foo</span><span class="ruby-operator">/</span>);
|
|
1132
|
+
|
|
1133
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">match</span>
|
|
1134
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">RegExp</span>} <span class="ruby-constant">RegularExpression</span>
|
|
1135
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1136
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1137
|
+
<span class="ruby-node">/
|
|
1138
|
+
|
|
1139
|
+
Assertion.addMethod('match', function(re, msg) {
|
|
1140
|
+
if (msg) flag(this, 'message', msg);
|
|
1141
|
+
var obj = flag(this, 'object');
|
|
1142
|
+
this.assert(
|
|
1143
|
+
re.exec(obj), 'expected #{this} to match ' + re, 'expected #{this} not to match ' + re);
|
|
1144
|
+
});
|
|
1145
|
+
|
|
1146
|
+
/</span><span class="ruby-operator">**</span>
|
|
1147
|
+
<span class="ruby-comment">### .string(string)</span>
|
|
1148
|
+
|
|
1149
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">string</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">another</span> <span class="ruby-identifier">string</span>.
|
|
1150
|
+
|
|
1151
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-string">'foobar'</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">string</span>(<span class="ruby-string">'bar'</span>);
|
|
1152
|
+
|
|
1153
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">string</span>
|
|
1154
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">string</span>
|
|
1155
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1156
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1157
|
+
<span class="ruby-node">/
|
|
1158
|
+
|
|
1159
|
+
Assertion.addMethod('string', function(str, msg) {
|
|
1160
|
+
if (msg) flag(this, 'message', msg);
|
|
1161
|
+
var obj = flag(this, 'object');
|
|
1162
|
+
new Assertion(obj, msg).is.a('string');
|
|
1163
|
+
|
|
1164
|
+
this.assert(~obj.indexOf(str), 'expected #{this} to contain ' + _.inspect(str), 'expected #{this} to not contain ' + _.inspect(str));
|
|
1165
|
+
});
|
|
1166
|
+
|
|
1167
|
+
/</span><span class="ruby-operator">**</span>
|
|
1168
|
+
<span class="ruby-comment">### .keys(key1, [key2], [...])</span>
|
|
1169
|
+
|
|
1170
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">exactly</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">given</span> <span class="ruby-identifier">keys</span>, <span class="ruby-keyword">or</span>
|
|
1171
|
+
<span class="ruby-identifier">asserts</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">inclusion</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">some</span> <span class="ruby-identifier">keys</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">using</span> <span class="ruby-identifier">the</span>
|
|
1172
|
+
<span class="ruby-value">%xinclude`</span> <span class="ruby-keyword">or</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">modifiers</span>.
|
|
1173
|
+
|
|
1174
|
+
<span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-value">1</span>, <span class="ruby-identifier">bar</span><span class="ruby-operator">:</span> <span class="ruby-value">2</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">keys</span>([<span class="ruby-string">'foo'</span>, <span class="ruby-string">'bar'</span>]);
|
|
1175
|
+
<span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-value">1</span>, <span class="ruby-identifier">bar</span><span class="ruby-operator">:</span> <span class="ruby-value">2</span>, <span class="ruby-identifier">baz</span><span class="ruby-operator">:</span> <span class="ruby-value">3</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">contain</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-string">'foo'</span>, <span class="ruby-string">'bar'</span>);
|
|
1176
|
+
|
|
1177
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">keys</span>
|
|
1178
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">key</span>
|
|
1179
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span><span class="ruby-operator">...</span><span class="ruby-operator">|</span><span class="ruby-constant">Array</span>} <span class="ruby-identifier">keys</span>
|
|
1180
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1181
|
+
<span class="ruby-regexp">/
|
|
1182
|
+
|
|
1183
|
+
function assertKeys(keys) {
|
|
1184
|
+
var obj = flag(this, 'object'),
|
|
1185
|
+
str, ok = true;
|
|
1186
|
+
|
|
1187
|
+
keys = keys instanceof Array ? keys : Array.prototype.slice.call(arguments);
|
|
1188
|
+
|
|
1189
|
+
if (!keys.length) throw new Error('keys required');
|
|
1190
|
+
|
|
1191
|
+
var actual = Object.keys(obj),
|
|
1192
|
+
len = keys.length;
|
|
1193
|
+
|
|
1194
|
+
/</span><span class="ruby-operator">/</span> <span class="ruby-constant">Inclusion</span>
|
|
1195
|
+
<span class="ruby-identifier">ok</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">every</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
|
|
1196
|
+
<span class="ruby-keyword">return</span> <span class="ruby-operator">~</span><span class="ruby-identifier">actual</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">key</span>);
|
|
1197
|
+
});
|
|
1198
|
+
|
|
1199
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Strict</span>
|
|
1200
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'negate'</span>) <span class="ruby-operator">&&</span> <span class="ruby-operator">!</span><span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'contains'</span>)) {
|
|
1201
|
+
<span class="ruby-identifier">ok</span> = <span class="ruby-identifier">ok</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">actual</span>.<span class="ruby-identifier">length</span>;
|
|
1202
|
+
}
|
|
1203
|
+
|
|
1204
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Key</span> <span class="ruby-identifier">string</span>
|
|
1205
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">len</span> <span class="ruby-operator">></span> <span class="ruby-value">1</span>) {
|
|
1206
|
+
<span class="ruby-identifier">keys</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
|
|
1207
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">_</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">key</span>);
|
|
1208
|
+
});
|
|
1209
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">last</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">pop</span>();
|
|
1210
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">', '</span>) <span class="ruby-operator">+</span> <span class="ruby-string">', and '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">last</span>;
|
|
1211
|
+
} <span class="ruby-keyword">else</span> {
|
|
1212
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">_</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">keys</span>[<span class="ruby-value">0</span>]);
|
|
1213
|
+
}
|
|
1214
|
+
|
|
1215
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Form</span>
|
|
1216
|
+
<span class="ruby-identifier">str</span> = (<span class="ruby-identifier">len</span> <span class="ruby-operator">></span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span> <span class="ruby-string">'keys '</span> <span class="ruby-operator">:</span> <span class="ruby-string">'key '</span>) <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
|
|
1217
|
+
|
|
1218
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Have</span> <span class="ruby-operator">/</span> <span class="ruby-identifier">include</span>
|
|
1219
|
+
<span class="ruby-identifier">str</span> = (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'contains'</span>) <span class="ruby-operator">?</span> <span class="ruby-string">'contain '</span> <span class="ruby-operator">:</span> <span class="ruby-string">'have '</span>) <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
|
|
1220
|
+
|
|
1221
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Assertion</span>
|
|
1222
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
1223
|
+
<span class="ruby-identifier">ok</span>, <span class="ruby-string">'expected #{this} to '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>, <span class="ruby-string">'expected #{this} to not '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>);
|
|
1224
|
+
}
|
|
1225
|
+
|
|
1226
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'keys'</span>, <span class="ruby-identifier">assertKeys</span>);
|
|
1227
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'key'</span>, <span class="ruby-identifier">assertKeys</span>);
|
|
1228
|
+
|
|
1229
|
+
<span class="ruby-node">/**
|
|
1230
|
+
### .throw(constructor)
|
|
1231
|
+
|
|
1232
|
+
Asserts that the function target will throw a specific error, or specific type of error
|
|
1233
|
+
(as determined using `instanceof`), optionally with a RegExp or string inclusion test
|
|
1234
|
+
for the error's message.
|
|
1235
|
+
|
|
1236
|
+
var err = new ReferenceError('This is a bad function.');
|
|
1237
|
+
var fn = function () { throw err; }
|
|
1238
|
+
expect(fn).to.throw(ReferenceError);
|
|
1239
|
+
expect(fn).to.throw(Error);
|
|
1240
|
+
expect(fn).to.throw(/</span><span class="ruby-identifier">bad</span> <span class="ruby-identifier">function</span><span class="ruby-operator">/</span>);
|
|
1241
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-string">'good function'</span>);
|
|
1242
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-constant">ReferenceError</span>, <span class="ruby-regexp">/bad function/</span>);
|
|
1243
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-identifier">err</span>);
|
|
1244
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-identifier">new</span> <span class="ruby-constant">RangeError</span>(<span class="ruby-string">'Out of range.'</span>));
|
|
1245
|
+
|
|
1246
|
+
<span class="ruby-constant">Please</span> <span class="ruby-identifier">note</span> <span class="ruby-identifier">that</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">throw</span> <span class="ruby-identifier">expectation</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">negated</span>, <span class="ruby-identifier">it</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">check</span> <span class="ruby-identifier">each</span>
|
|
1247
|
+
<span class="ruby-identifier">parameter</span> <span class="ruby-identifier">independently</span>, <span class="ruby-identifier">starting</span> <span class="ruby-identifier">with</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">constructor</span> <span class="ruby-identifier">type</span>. <span class="ruby-constant">The</span> <span class="ruby-identifier">appropriate</span> <span class="ruby-identifier">way</span>
|
|
1248
|
+
<span class="ruby-identifier">to</span> <span class="ruby-identifier">check</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">existence</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">type</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">but</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">message</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">match</span>
|
|
1249
|
+
<span class="ruby-identifier">is</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">use</span> <span class="ruby-value">%xand`</span>.
|
|
1250
|
+
|
|
1251
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-constant">ReferenceError</span>)
|
|
1252
|
+
.<span class="ruby-identifier">and</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-regexp">/good function/</span>);
|
|
1253
|
+
|
|
1254
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">throw</span>
|
|
1255
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-identifier">throws</span>
|
|
1256
|
+
<span class="ruby-ivar">@alias</span> <span class="ruby-constant">Throw</span>
|
|
1257
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">ErrorConstructor</span>} <span class="ruby-identifier">constructor</span>
|
|
1258
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span><span class="ruby-operator">|</span><span class="ruby-constant">RegExp</span>} <span class="ruby-identifier">expected</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">message</span>
|
|
1259
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1260
|
+
<span class="ruby-ivar">@see</span> <span class="ruby-identifier">https</span><span class="ruby-operator">:</span><span class="ruby-regexp">//</span><span class="ruby-identifier">developer</span>.<span class="ruby-identifier">mozilla</span>.<span class="ruby-identifier">org</span><span class="ruby-operator">/</span><span class="ruby-identifier">en</span><span class="ruby-operator">/</span><span class="ruby-constant">JavaScript</span><span class="ruby-operator">/</span><span class="ruby-constant">Reference</span><span class="ruby-operator">/</span><span class="ruby-constant">Global_Objects</span><span class="ruby-operator">/</span><span class="ruby-constant">Error</span><span class="ruby-comment">#Error_types</span>
|
|
1261
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1262
|
+
<span class="ruby-regexp">/
|
|
1263
|
+
|
|
1264
|
+
function assertThrows(constructor, errMsg, msg) {
|
|
1265
|
+
if (msg) flag(this, 'message', msg);
|
|
1266
|
+
var obj = flag(this, 'object');
|
|
1267
|
+
new Assertion(obj, msg).is.a('function');
|
|
1268
|
+
|
|
1269
|
+
var thrown = false,
|
|
1270
|
+
desiredError = null,
|
|
1271
|
+
name = null,
|
|
1272
|
+
thrownError = null;
|
|
1273
|
+
|
|
1274
|
+
if (arguments.length === 0) {
|
|
1275
|
+
errMsg = null;
|
|
1276
|
+
constructor = null;
|
|
1277
|
+
} else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {
|
|
1278
|
+
errMsg = constructor;
|
|
1279
|
+
constructor = null;
|
|
1280
|
+
} else if (constructor && constructor instanceof Error) {
|
|
1281
|
+
desiredError = constructor;
|
|
1282
|
+
constructor = null;
|
|
1283
|
+
errMsg = null;
|
|
1284
|
+
} else if (typeof constructor === 'function') {
|
|
1285
|
+
name = (new constructor()).name;
|
|
1286
|
+
} else {
|
|
1287
|
+
constructor = null;
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
try {
|
|
1291
|
+
obj();
|
|
1292
|
+
} catch (err) {
|
|
1293
|
+
/</span><span class="ruby-operator">/</span> <span class="ruby-identifier">first</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">desired</span> <span class="ruby-identifier">error</span>
|
|
1294
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">desiredError</span>) {
|
|
1295
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
1296
|
+
<span class="ruby-identifier">err</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">desiredError</span>, <span class="ruby-string">'expected #{this} to throw #{exp} but #{act} was thrown'</span>, <span class="ruby-string">'expected #{this} to not throw #{exp}'</span>, <span class="ruby-identifier">desiredError</span>, <span class="ruby-identifier">err</span>);
|
|
1297
|
+
|
|
1298
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
1299
|
+
}
|
|
1300
|
+
<span class="ruby-regexp">//</span> <span class="ruby-keyword">next</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">constructor</span>
|
|
1301
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">constructor</span>) {
|
|
1302
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
1303
|
+
<span class="ruby-identifier">err</span> <span class="ruby-identifier">instanceof</span> <span class="ruby-identifier">constructor</span>, <span class="ruby-string">'expected #{this} to throw #{exp} but #{act} was thrown'</span>, <span class="ruby-string">'expected #{this} to not throw #{exp} but #{act} was thrown'</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">err</span>);
|
|
1304
|
+
|
|
1305
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">errMsg</span>) <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
1306
|
+
}
|
|
1307
|
+
<span class="ruby-regexp">//</span> <span class="ruby-keyword">next</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">message</span>
|
|
1308
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">message</span> = <span class="ruby-string">'object'</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">_</span>.<span class="ruby-identifier">type</span>(<span class="ruby-identifier">err</span>) <span class="ruby-operator">&&</span> <span class="ruby-string">"message"</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">err</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">err</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">:</span> <span class="ruby-string">''</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">err</span>;
|
|
1309
|
+
|
|
1310
|
+
<span class="ruby-keyword">if</span> ((<span class="ruby-identifier">message</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">null</span>) <span class="ruby-operator">&&</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-identifier">instanceof</span> <span class="ruby-constant">RegExp</span>) {
|
|
1311
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
1312
|
+
<span class="ruby-identifier">errMsg</span>.<span class="ruby-identifier">exec</span>(<span class="ruby-identifier">message</span>), <span class="ruby-string">'expected #{this} to throw error matching #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to throw error not matching #{exp}'</span>, <span class="ruby-identifier">errMsg</span>, <span class="ruby-identifier">message</span>);
|
|
1313
|
+
|
|
1314
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
1315
|
+
} <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> ((<span class="ruby-identifier">message</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">null</span>) <span class="ruby-operator">&&</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-operator">&&</span> <span class="ruby-string">'string'</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">errMsg</span>) {
|
|
1316
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(<span class="ruby-operator">~</span><span class="ruby-identifier">message</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">errMsg</span>), <span class="ruby-string">'expected #{this} to throw error including #{exp} but got #{act}'</span>, <span class="ruby-string">'expected #{this} to throw error not including #{act}'</span>, <span class="ruby-identifier">errMsg</span>, <span class="ruby-identifier">message</span>);
|
|
1317
|
+
|
|
1318
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
1319
|
+
} <span class="ruby-keyword">else</span> {
|
|
1320
|
+
<span class="ruby-identifier">thrown</span> = <span class="ruby-keyword">true</span>;
|
|
1321
|
+
<span class="ruby-identifier">thrownError</span> = <span class="ruby-identifier">err</span>;
|
|
1322
|
+
}
|
|
1323
|
+
}
|
|
1324
|
+
|
|
1325
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">actuallyGot</span> = <span class="ruby-string">''</span>,
|
|
1326
|
+
<span class="ruby-identifier">expectedThrown</span> = <span class="ruby-identifier">name</span> <span class="ruby-operator">!=</span>= <span class="ruby-identifier">null</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">desiredError</span> <span class="ruby-operator">?</span> <span class="ruby-string">'#{exp}'</span> <span class="ruby-operator">/</span><span class="ruby-node">/_.inspect(desiredError)
|
|
1327
|
+
:
|
|
1328
|
+
'an error';
|
|
1329
|
+
|
|
1330
|
+
if (thrown) {
|
|
1331
|
+
actuallyGot = ' but #{act} was thrown'
|
|
1332
|
+
}
|
|
1333
|
+
|
|
1334
|
+
this.assert(
|
|
1335
|
+
thrown === true, 'expected #{this} to throw ' + expectedThrown + actuallyGot, 'expected #{this} to not throw ' + expectedThrown + actuallyGot, desiredError, thrownError);
|
|
1336
|
+
};
|
|
1337
|
+
|
|
1338
|
+
Assertion.addMethod('throw', assertThrows);
|
|
1339
|
+
Assertion.addMethod('throws', assertThrows);
|
|
1340
|
+
Assertion.addMethod('Throw', assertThrows);
|
|
1341
|
+
|
|
1342
|
+
/</span><span class="ruby-operator">**</span>
|
|
1343
|
+
<span class="ruby-comment">### .respondTo(method)</span>
|
|
1344
|
+
|
|
1345
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">object</span> <span class="ruby-keyword">or</span> <span class="ruby-keyword">class</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">respond</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">method</span>.
|
|
1346
|
+
|
|
1347
|
+
<span class="ruby-constant">Klass</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">bar</span> = <span class="ruby-identifier">function</span>(){};
|
|
1348
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-constant">Klass</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">'bar'</span>);
|
|
1349
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">'bar'</span>);
|
|
1350
|
+
|
|
1351
|
+
<span class="ruby-constant">To</span> <span class="ruby-identifier">check</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">constructor</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">respond</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">static</span> <span class="ruby-identifier">function</span>,
|
|
1352
|
+
<span class="ruby-identifier">set</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xitself`</span> <span class="ruby-identifier">flag</span>.
|
|
1353
|
+
|
|
1354
|
+
<span class="ruby-constant">Klass</span>.<span class="ruby-identifier">baz</span> = <span class="ruby-identifier">function</span>(){};
|
|
1355
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-constant">Klass</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">'baz'</span>);
|
|
1356
|
+
|
|
1357
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">respondTo</span>
|
|
1358
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">method</span>
|
|
1359
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1360
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1361
|
+
<span class="ruby-node">/
|
|
1362
|
+
|
|
1363
|
+
Assertion.addMethod('respondTo', function(method, msg) {
|
|
1364
|
+
if (msg) flag(this, 'message', msg);
|
|
1365
|
+
var obj = flag(this, 'object'),
|
|
1366
|
+
itself = flag(this, 'itself'),
|
|
1367
|
+
context = ('function' === _.type(obj) && !itself) ? obj.prototype[method] : obj[method];
|
|
1368
|
+
|
|
1369
|
+
this.assert('function' === typeof context, 'expected #{this} to respond to ' + _.inspect(method), 'expected #{this} to not respond to ' + _.inspect(method));
|
|
1370
|
+
});
|
|
1371
|
+
|
|
1372
|
+
/</span><span class="ruby-operator">**</span>
|
|
1373
|
+
<span class="ruby-comment">### .itself</span>
|
|
1374
|
+
|
|
1375
|
+
<span class="ruby-constant">Sets</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xitself`</span> <span class="ruby-identifier">flag</span>, <span class="ruby-identifier">later</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">by</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xrespondTo`</span> <span class="ruby-identifier">assertion</span>.
|
|
1376
|
+
|
|
1377
|
+
<span class="ruby-identifier">function</span> <span class="ruby-constant">Foo</span>() {}
|
|
1378
|
+
<span class="ruby-constant">Foo</span>.<span class="ruby-identifier">bar</span> = <span class="ruby-identifier">function</span>() {}
|
|
1379
|
+
<span class="ruby-constant">Foo</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">baz</span> = <span class="ruby-identifier">function</span>() {}
|
|
1380
|
+
|
|
1381
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-constant">Foo</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">'bar'</span>);
|
|
1382
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-constant">Foo</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">'baz'</span>);
|
|
1383
|
+
|
|
1384
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">itself</span>
|
|
1385
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1386
|
+
<span class="ruby-regexp">/
|
|
1387
|
+
|
|
1388
|
+
Assertion.addProperty('itself', function() {
|
|
1389
|
+
flag(this, 'itself', true);
|
|
1390
|
+
});
|
|
1391
|
+
|
|
1392
|
+
/</span><span class="ruby-operator">**</span>
|
|
1393
|
+
<span class="ruby-comment">### .satisfy(method)</span>
|
|
1394
|
+
|
|
1395
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">passes</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">given</span> <span class="ruby-identifier">truth</span> <span class="ruby-identifier">test</span>.
|
|
1396
|
+
|
|
1397
|
+
<span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">satisfy</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">num</span>) { <span class="ruby-keyword">return</span> <span class="ruby-identifier">num</span> <span class="ruby-operator">></span> <span class="ruby-value">0</span>; });
|
|
1398
|
+
|
|
1399
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">satisfy</span>
|
|
1400
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">Function</span>} <span class="ruby-identifier">matcher</span>
|
|
1401
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
|
|
1402
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
1403
|
+
<span class="ruby-node">/
|
|
1404
|
+
|
|
1405
|
+
Assertion.addMethod('satisfy', function(matcher, msg) {
|
|
1406
|
+
if (msg) flag(this, 'message', msg);
|
|
1407
|
+
var obj = flag(this, 'object');
|
|
1408
|
+
this.assert(
|
|
1409
|
+
matcher(obj), 'expected #{this} to satisfy ' + _.objDisplay(matcher), 'expected #{this} to not satisfy' + _.objDisplay(matcher), this.negate ? false : true, matcher(obj));
|
|
1410
|
+
});
|
|
1411
|
+
|
|
1412
|
+
/</span><span class="ruby-operator">**</span>
|
|
1413
|
+
<span class="ruby-comment">### .closeTo(expected, delta)</span>
|
|
1414
|
+
|
|
1415
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">equal</span> <span class="ruby-value">%xexpected`</span>, <span class="ruby-identifier">to</span> <span class="ruby-identifier">within</span> <span class="ruby-identifier">a</span> <span class="ruby-operator">+</span><span class="ruby-regexp">/- `delta` range.
|
|
1416
|
+
|
|
1417
|
+
expect(1.5).to.be.closeTo(1, 0.5);
|
|
1418
|
+
|
|
1419
|
+
@name closeTo
|
|
1420
|
+
@param {Number} expected
|
|
1421
|
+
@param {Number} delta
|
|
1422
|
+
@param {String} message _optional_
|
|
1423
|
+
@api public
|
|
1424
|
+
/</span>
|
|
1425
|
+
|
|
1426
|
+
<span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">'closeTo'</span>, <span class="ruby-identifier">function</span>(<span class="ruby-identifier">expected</span>, <span class="ruby-identifier">delta</span>, <span class="ruby-identifier">msg</span>) {
|
|
1427
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'message'</span>, <span class="ruby-identifier">msg</span>);
|
|
1428
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">'object'</span>);
|
|
1429
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
|
|
1430
|
+
<span class="ruby-constant">Math</span>.<span class="ruby-identifier">abs</span>(<span class="ruby-identifier">obj</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">expected</span>) <span class="ruby-operator"><=</span> <span class="ruby-identifier">delta</span>, <span class="ruby-string">'expected #{this} to be close to '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">expected</span> <span class="ruby-operator">+</span> <span class="ruby-string">' +/- '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">delta</span>, <span class="ruby-string">'expected #{this} not to be close to '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">expected</span> <span class="ruby-operator">+</span> <span class="ruby-string">' +/- '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">delta</span>);
|
|
1431
|
+
});
|
|
1432
|
+
|
|
1433
|
+
};
|
|
1434
|
+
|
|
1435
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">core</span><span class="ruby-operator">/</span><span class="ruby-identifier">assertions</span>.<span class="ruby-identifier">js</span>
|
|
1436
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/error.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
1437
|
+
<span class="ruby-regexp">/*!
|
|
1438
|
+
chai
|
|
1439
|
+
Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
|
|
1440
|
+
MIT Licensed
|
|
1441
|
+
/</span>
|
|
1442
|
+
|
|
1443
|
+
<span class="ruby-regexp">/*!
|
|
1444
|
+
Main export
|
|
1445
|
+
/</span>
|
|
1446
|
+
|
|
1447
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-constant">AssertionError</span>;
|
|
1448
|
+
|
|
1449
|
+
<span class="ruby-node">/**
|
|
1450
|
+
# AssertionError (constructor)
|
|
1451
|
+
|
|
1452
|
+
Create a new assertion error based on the Javascript
|
|
1453
|
+
`Error` prototype.
|
|
1454
|
+
|
|
1455
|
+
**Options**
|
|
1456
|
+
- message
|
|
1457
|
+
- actual
|
|
1458
|
+
- expected
|
|
1459
|
+
- operator
|
|
1460
|
+
- startStackFunction
|
|
1461
|
+
|
|
1462
|
+
@param {Object} options
|
|
1463
|
+
@api public
|
|
1464
|
+
/</span>
|
|
1465
|
+
|
|
1466
|
+
<span class="ruby-identifier">function</span> <span class="ruby-constant">AssertionError</span>(<span class="ruby-identifier">options</span>) {
|
|
1467
|
+
<span class="ruby-identifier">options</span> = <span class="ruby-identifier">options</span> <span class="ruby-operator">||</span> {};
|
|
1468
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">message</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">message</span>;
|
|
1469
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">actual</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">actual</span>;
|
|
1470
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">expected</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">expected</span>;
|
|
1471
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">operator</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">operator</span>;
|
|
1472
|
+
<span class="ruby-identifier">this</span>.<span class="ruby-identifier">showDiff</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">showDiff</span>;
|
|
1473
|
+
|
|
1474
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">options</span>.<span class="ruby-identifier">stackStartFunction</span> <span class="ruby-operator">&&</span> <span class="ruby-constant">Error</span>.<span class="ruby-identifier">captureStackTrace</span>) {
|
|
1475
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">stackStartFunction</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">stackStartFunction</span>;
|
|
1476
|
+
<span class="ruby-constant">Error</span>.<span class="ruby-identifier">captureStackTrace</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">stackStartFunction</span>);
|
|
1477
|
+
}
|
|
1478
|
+
}
|
|
1479
|
+
|
|
1480
|
+
<span class="ruby-regexp">/*!
|
|
1481
|
+
Inherit from Error
|
|
1482
|
+
/</span>
|
|
1483
|
+
|
|
1484
|
+
<span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-constant">Error</span>.<span class="ruby-identifier">prototype</span>);
|
|
1485
|
+
<span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">name</span> = <span class="ruby-string">'AssertionError'</span>;
|
|
1486
|
+
<span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">constructor</span> = <span class="ruby-constant">AssertionError</span>;
|
|
1487
|
+
|
|
1488
|
+
<span class="ruby-node">/**
|
|
1489
|
+
# toString()
|
|
1490
|
+
|
|
1491
|
+
Override default to string method
|
|
1492
|
+
/</span>
|
|
1493
|
+
|
|
1494
|
+
<span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span> = <span class="ruby-identifier">function</span>() {
|
|
1495
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>.<span class="ruby-identifier">message</span>;
|
|
1496
|
+
};
|
|
1497
|
+
|
|
1498
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">error</span>.<span class="ruby-identifier">js</span>
|
|
1499
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/interface/assert.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
1500
|
+
<span class="ruby-regexp">/*!
|
|
1501
|
+
chai
|
|
1502
|
+
Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
|
|
1503
|
+
MIT Licensed
|
|
1504
|
+
/</span>
|
|
1505
|
+
|
|
1506
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">chai</span>, <span class="ruby-identifier">util</span>) {
|
|
1507
|
+
|
|
1508
|
+
<span class="ruby-regexp">/*!
|
|
1509
|
+
Chai dependencies.
|
|
1510
|
+
/</span>
|
|
1511
|
+
|
|
1512
|
+
<span class="ruby-identifier">var</span> <span class="ruby-constant">Assertion</span> = <span class="ruby-identifier">chai</span>.<span class="ruby-constant">Assertion</span>,
|
|
1513
|
+
<span class="ruby-identifier">flag</span> = <span class="ruby-identifier">util</span>.<span class="ruby-identifier">flag</span>;
|
|
1514
|
+
|
|
1515
|
+
<span class="ruby-regexp">/*!
|
|
1516
|
+
Module export.
|
|
1517
|
+
/</span>
|
|
1518
|
+
|
|
1519
|
+
<span class="ruby-node">/**
|
|
1520
|
+
### assert(expression, message)
|
|
1521
|
+
|
|
1522
|
+
Write your own test expressions.
|
|
1523
|
+
|
|
1524
|
+
assert('foo' !== 'bar', 'foo is not bar');
|
|
1525
|
+
assert(Array.isArray([]), 'empty arrays are arrays');
|
|
1526
|
+
|
|
1527
|
+
@param {Mixed} expression to test for truthiness
|
|
1528
|
+
@param {String} message to display on error
|
|
1529
|
+
@name assert
|
|
1530
|
+
@api public
|
|
1531
|
+
/</span>
|
|
1532
|
+
|
|
1533
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">assert</span> = <span class="ruby-identifier">chai</span>.<span class="ruby-identifier">assert</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">express</span>, <span class="ruby-identifier">errmsg</span>) {
|
|
1534
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">null</span>);
|
|
1535
|
+
<span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
|
|
1536
|
+
<span class="ruby-identifier">express</span>, <span class="ruby-identifier">errmsg</span>, <span class="ruby-string">'[ negation message unavailable ]'</span>);
|
|
1537
|
+
};
|
|
1538
|
+
|
|
1539
|
+
<span class="ruby-node">/**
|
|
1540
|
+
### .fail(actual, expected, [message], [operator])
|
|
1541
|
+
|
|
1542
|
+
Throw a failure. Node.js `assert` module-compatible.
|
|
1543
|
+
|
|
1544
|
+
@name fail
|
|
1545
|
+
@param {Mixed} actual
|
|
1546
|
+
@param {Mixed} expected
|
|
1547
|
+
@param {String} message
|
|
1548
|
+
@param {String} operator
|
|
1549
|
+
@api public
|
|
1550
|
+
/</span>
|
|
1551
|
+
|
|
1552
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">fail</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">actual</span>, <span class="ruby-identifier">expected</span>, <span class="ruby-identifier">message</span>, <span class="ruby-identifier">operator</span>) {
|
|
1553
|
+
<span class="ruby-identifier">throw</span> <span class="ruby-identifier">new</span> <span class="ruby-identifier">chai</span>.<span class="ruby-constant">AssertionError</span>({
|
|
1554
|
+
<span class="ruby-identifier">actual</span><span class="ruby-operator">:</span> <span class="ruby-identifier">actual</span>,
|
|
1555
|
+
<span class="ruby-identifier">expected</span><span class="ruby-operator">:</span> <span class="ruby-identifier">expected</span>,
|
|
1556
|
+
<span class="ruby-identifier">message</span><span class="ruby-operator">:</span> <span class="ruby-identifier">message</span>,
|
|
1557
|
+
<span class="ruby-identifier">operator</span><span class="ruby-operator">:</span> <span class="ruby-identifier">operator</span>,
|
|
1558
|
+
<span class="ruby-identifier">stackStartFunction</span><span class="ruby-operator">:</span> <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">fail</span>
|
|
1559
|
+
});
|
|
1560
|
+
};
|
|
1561
|
+
|
|
1562
|
+
<span class="ruby-node">/**
|
|
1563
|
+
### .ok(object, [message])
|
|
1564
|
+
|
|
1565
|
+
Asserts that `object` is truthy.
|
|
1566
|
+
|
|
1567
|
+
assert.ok('everything', 'everything is ok');
|
|
1568
|
+
assert.ok(false, 'this will fail');
|
|
1569
|
+
|
|
1570
|
+
@name ok
|
|
1571
|
+
@param {Mixed} object to test
|
|
1572
|
+
@param {String} message
|
|
1573
|
+
@api public
|
|
1574
|
+
/</span>
|
|
1575
|
+
|
|
1576
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">ok</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1577
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>.<span class="ruby-identifier">ok</span>;
|
|
1578
|
+
};
|
|
1579
|
+
|
|
1580
|
+
<span class="ruby-node">/**
|
|
1581
|
+
### .equal(actual, expected, [message])
|
|
1582
|
+
|
|
1583
|
+
Asserts non-strict equality (`==`) of `actual` and `expected`.
|
|
1584
|
+
|
|
1585
|
+
assert.equal(3, '3', '== coerces values to strings');
|
|
1586
|
+
|
|
1587
|
+
@name equal
|
|
1588
|
+
@param {Mixed} actual
|
|
1589
|
+
@param {Mixed} expected
|
|
1590
|
+
@param {String} message
|
|
1591
|
+
@api public
|
|
1592
|
+
/</span>
|
|
1593
|
+
|
|
1594
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">equal</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1595
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>);
|
|
1596
|
+
|
|
1597
|
+
<span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
|
|
1598
|
+
<span class="ruby-identifier">exp</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">test</span>, <span class="ruby-string">'object'</span>), <span class="ruby-string">'expected #{this} to equal #{exp}'</span>, <span class="ruby-string">'expected #{this} to not equal #{act}'</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">act</span>);
|
|
1599
|
+
};
|
|
1600
|
+
|
|
1601
|
+
<span class="ruby-node">/**
|
|
1602
|
+
### .notEqual(actual, expected, [message])
|
|
1603
|
+
|
|
1604
|
+
Asserts non-strict inequality (`!=`) of `actual` and `expected`.
|
|
1605
|
+
|
|
1606
|
+
assert.notEqual(3, 4, 'these numbers are not equal');
|
|
1607
|
+
|
|
1608
|
+
@name notEqual
|
|
1609
|
+
@param {Mixed} actual
|
|
1610
|
+
@param {Mixed} expected
|
|
1611
|
+
@param {String} message
|
|
1612
|
+
@api public
|
|
1613
|
+
/</span>
|
|
1614
|
+
|
|
1615
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1616
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>);
|
|
1617
|
+
|
|
1618
|
+
<span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
|
|
1619
|
+
<span class="ruby-identifier">exp</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">test</span>, <span class="ruby-string">'object'</span>), <span class="ruby-string">'expected #{this} to not equal #{exp}'</span>, <span class="ruby-string">'expected #{this} to equal #{act}'</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">act</span>);
|
|
1620
|
+
};
|
|
1621
|
+
|
|
1622
|
+
<span class="ruby-node">/**
|
|
1623
|
+
### .strictEqual(actual, expected, [message])
|
|
1624
|
+
|
|
1625
|
+
Asserts strict equality (`===`) of `actual` and `expected`.
|
|
1626
|
+
|
|
1627
|
+
assert.strictEqual(true, true, 'these booleans are strictly equal');
|
|
1628
|
+
|
|
1629
|
+
@name strictEqual
|
|
1630
|
+
@param {Mixed} actual
|
|
1631
|
+
@param {Mixed} expected
|
|
1632
|
+
@param {String} message
|
|
1633
|
+
@api public
|
|
1634
|
+
/</span>
|
|
1635
|
+
|
|
1636
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">strictEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1637
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">exp</span>);
|
|
1638
|
+
};
|
|
1639
|
+
|
|
1640
|
+
<span class="ruby-node">/**
|
|
1641
|
+
### .notStrictEqual(actual, expected, [message])
|
|
1642
|
+
|
|
1643
|
+
Asserts strict inequality (`!==`) of `actual` and `expected`.
|
|
1644
|
+
|
|
1645
|
+
assert.notStrictEqual(3, '3', 'no coercion for strict equality');
|
|
1646
|
+
|
|
1647
|
+
@name notStrictEqual
|
|
1648
|
+
@param {Mixed} actual
|
|
1649
|
+
@param {Mixed} expected
|
|
1650
|
+
@param {String} message
|
|
1651
|
+
@api public
|
|
1652
|
+
/</span>
|
|
1653
|
+
|
|
1654
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notStrictEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1655
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">exp</span>);
|
|
1656
|
+
};
|
|
1657
|
+
|
|
1658
|
+
<span class="ruby-node">/**
|
|
1659
|
+
### .deepEqual(actual, expected, [message])
|
|
1660
|
+
|
|
1661
|
+
Asserts that `actual` is deeply equal to `expected`.
|
|
1662
|
+
|
|
1663
|
+
assert.deepEqual({ tea: 'green' }, { tea: 'green' });
|
|
1664
|
+
|
|
1665
|
+
@name deepEqual
|
|
1666
|
+
@param {Mixed} actual
|
|
1667
|
+
@param {Mixed} expected
|
|
1668
|
+
@param {String} message
|
|
1669
|
+
@api public
|
|
1670
|
+
/</span>
|
|
1671
|
+
|
|
1672
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">deepEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1673
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">exp</span>);
|
|
1674
|
+
};
|
|
1675
|
+
|
|
1676
|
+
<span class="ruby-node">/**
|
|
1677
|
+
### .notDeepEqual(actual, expected, [message])
|
|
1678
|
+
|
|
1679
|
+
Assert that `actual` is not deeply equal to `expected`.
|
|
1680
|
+
|
|
1681
|
+
assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
|
|
1682
|
+
|
|
1683
|
+
@name notDeepEqual
|
|
1684
|
+
@param {Mixed} actual
|
|
1685
|
+
@param {Mixed} expected
|
|
1686
|
+
@param {String} message
|
|
1687
|
+
@api public
|
|
1688
|
+
/</span>
|
|
1689
|
+
|
|
1690
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notDeepEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
|
|
1691
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">exp</span>);
|
|
1692
|
+
};
|
|
1693
|
+
|
|
1694
|
+
<span class="ruby-node">/**
|
|
1695
|
+
### .isTrue(value, [message])
|
|
1696
|
+
|
|
1697
|
+
Asserts that `value` is true.
|
|
1698
|
+
|
|
1699
|
+
var teaServed = true;
|
|
1700
|
+
assert.isTrue(teaServed, 'the tea has been served');
|
|
1701
|
+
|
|
1702
|
+
@name isTrue
|
|
1703
|
+
@param {Mixed} value
|
|
1704
|
+
@param {String} message
|
|
1705
|
+
@api public
|
|
1706
|
+
/</span>
|
|
1707
|
+
|
|
1708
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isTrue</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1709
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>[<span class="ruby-string">'true'</span>];
|
|
1710
|
+
};
|
|
1711
|
+
|
|
1712
|
+
<span class="ruby-node">/**
|
|
1713
|
+
### .isFalse(value, [message])
|
|
1714
|
+
|
|
1715
|
+
Asserts that `value` is false.
|
|
1716
|
+
|
|
1717
|
+
var teaServed = false;
|
|
1718
|
+
assert.isFalse(teaServed, 'no tea yet? hmm...');
|
|
1719
|
+
|
|
1720
|
+
@name isFalse
|
|
1721
|
+
@param {Mixed} value
|
|
1722
|
+
@param {String} message
|
|
1723
|
+
@api public
|
|
1724
|
+
/</span>
|
|
1725
|
+
|
|
1726
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isFalse</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1727
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>[<span class="ruby-string">'false'</span>];
|
|
1728
|
+
};
|
|
1729
|
+
|
|
1730
|
+
<span class="ruby-node">/**
|
|
1731
|
+
### .isNull(value, [message])
|
|
1732
|
+
|
|
1733
|
+
Asserts that `value` is null.
|
|
1734
|
+
|
|
1735
|
+
assert.isNull(err, 'there was no error');
|
|
1736
|
+
|
|
1737
|
+
@name isNull
|
|
1738
|
+
@param {Mixed} value
|
|
1739
|
+
@param {String} message
|
|
1740
|
+
@api public
|
|
1741
|
+
/</span>
|
|
1742
|
+
|
|
1743
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNull</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1744
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">null</span>);
|
|
1745
|
+
};
|
|
1746
|
+
|
|
1747
|
+
<span class="ruby-node">/**
|
|
1748
|
+
### .isNotNull(value, [message])
|
|
1749
|
+
|
|
1750
|
+
Asserts that `value` is not null.
|
|
1751
|
+
|
|
1752
|
+
var tea = 'tasty chai';
|
|
1753
|
+
assert.isNotNull(tea, 'great, time for tea!');
|
|
1754
|
+
|
|
1755
|
+
@name isNotNull
|
|
1756
|
+
@param {Mixed} value
|
|
1757
|
+
@param {String} message
|
|
1758
|
+
@api public
|
|
1759
|
+
/</span>
|
|
1760
|
+
|
|
1761
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotNull</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1762
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">null</span>);
|
|
1763
|
+
};
|
|
1764
|
+
|
|
1765
|
+
<span class="ruby-node">/**
|
|
1766
|
+
### .isUndefined(value, [message])
|
|
1767
|
+
|
|
1768
|
+
Asserts that `value` is `undefined`.
|
|
1769
|
+
|
|
1770
|
+
var tea;
|
|
1771
|
+
assert.isUndefined(tea, 'no tea defined');
|
|
1772
|
+
|
|
1773
|
+
@name isUndefined
|
|
1774
|
+
@param {Mixed} value
|
|
1775
|
+
@param {String} message
|
|
1776
|
+
@api public
|
|
1777
|
+
/</span>
|
|
1778
|
+
|
|
1779
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isUndefined</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1780
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">undefined</span>);
|
|
1781
|
+
};
|
|
1782
|
+
|
|
1783
|
+
<span class="ruby-node">/**
|
|
1784
|
+
### .isDefined(value, [message])
|
|
1785
|
+
|
|
1786
|
+
Asserts that `value` is not `undefined`.
|
|
1787
|
+
|
|
1788
|
+
var tea = 'cup of chai';
|
|
1789
|
+
assert.isDefined(tea, 'tea has been defined');
|
|
1790
|
+
|
|
1791
|
+
@name isUndefined
|
|
1792
|
+
@param {Mixed} value
|
|
1793
|
+
@param {String} message
|
|
1794
|
+
@api public
|
|
1795
|
+
/</span>
|
|
1796
|
+
|
|
1797
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isDefined</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1798
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">undefined</span>);
|
|
1799
|
+
};
|
|
1800
|
+
|
|
1801
|
+
<span class="ruby-node">/**
|
|
1802
|
+
### .isFunction(value, [message])
|
|
1803
|
+
|
|
1804
|
+
Asserts that `value` is a function.
|
|
1805
|
+
|
|
1806
|
+
function serveTea() { return 'cup of tea'; };
|
|
1807
|
+
assert.isFunction(serveTea, 'great, we can have tea now');
|
|
1808
|
+
|
|
1809
|
+
@name isFunction
|
|
1810
|
+
@param {Mixed} value
|
|
1811
|
+
@param {String} message
|
|
1812
|
+
@api public
|
|
1813
|
+
/</span>
|
|
1814
|
+
|
|
1815
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isFunction</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1816
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'function'</span>);
|
|
1817
|
+
};
|
|
1818
|
+
|
|
1819
|
+
<span class="ruby-node">/**
|
|
1820
|
+
### .isNotFunction(value, [message])
|
|
1821
|
+
|
|
1822
|
+
Asserts that `value` is _not_ a function.
|
|
1823
|
+
|
|
1824
|
+
var serveTea = [ 'heat', 'pour', 'sip' ];
|
|
1825
|
+
assert.isNotFunction(serveTea, 'great, we have listed the steps');
|
|
1826
|
+
|
|
1827
|
+
@name isNotFunction
|
|
1828
|
+
@param {Mixed} value
|
|
1829
|
+
@param {String} message
|
|
1830
|
+
@api public
|
|
1831
|
+
/</span>
|
|
1832
|
+
|
|
1833
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotFunction</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1834
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'function'</span>);
|
|
1835
|
+
};
|
|
1836
|
+
|
|
1837
|
+
<span class="ruby-node">/**
|
|
1838
|
+
### .isObject(value, [message])
|
|
1839
|
+
|
|
1840
|
+
Asserts that `value` is an object (as revealed by
|
|
1841
|
+
`Object.prototype.toString`).
|
|
1842
|
+
|
|
1843
|
+
var selection = { name: 'Chai', serve: 'with spices' };
|
|
1844
|
+
assert.isObject(selection, 'tea selection is an object');
|
|
1845
|
+
|
|
1846
|
+
@name isObject
|
|
1847
|
+
@param {Mixed} value
|
|
1848
|
+
@param {String} message
|
|
1849
|
+
@api public
|
|
1850
|
+
/</span>
|
|
1851
|
+
|
|
1852
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isObject</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1853
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'object'</span>);
|
|
1854
|
+
};
|
|
1855
|
+
|
|
1856
|
+
<span class="ruby-node">/**
|
|
1857
|
+
### .isNotObject(value, [message])
|
|
1858
|
+
|
|
1859
|
+
Asserts that `value` is _not_ an object.
|
|
1860
|
+
|
|
1861
|
+
var selection = 'chai'
|
|
1862
|
+
assert.isObject(selection, 'tea selection is not an object');
|
|
1863
|
+
assert.isObject(null, 'null is not an object');
|
|
1864
|
+
|
|
1865
|
+
@name isNotObject
|
|
1866
|
+
@param {Mixed} value
|
|
1867
|
+
@param {String} message
|
|
1868
|
+
@api public
|
|
1869
|
+
/</span>
|
|
1870
|
+
|
|
1871
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotObject</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1872
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'object'</span>);
|
|
1873
|
+
};
|
|
1874
|
+
|
|
1875
|
+
<span class="ruby-node">/**
|
|
1876
|
+
### .isArray(value, [message])
|
|
1877
|
+
|
|
1878
|
+
Asserts that `value` is an array.
|
|
1879
|
+
|
|
1880
|
+
var menu = [ 'green', 'chai', 'oolong' ];
|
|
1881
|
+
assert.isArray(menu, 'what kind of tea do we want?');
|
|
1882
|
+
|
|
1883
|
+
@name isArray
|
|
1884
|
+
@param {Mixed} value
|
|
1885
|
+
@param {String} message
|
|
1886
|
+
@api public
|
|
1887
|
+
/</span>
|
|
1888
|
+
|
|
1889
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isArray</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1890
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">'array'</span>);
|
|
1891
|
+
};
|
|
1892
|
+
|
|
1893
|
+
<span class="ruby-node">/**
|
|
1894
|
+
### .isNotArray(value, [message])
|
|
1895
|
+
|
|
1896
|
+
Asserts that `value` is _not_ an array.
|
|
1897
|
+
|
|
1898
|
+
var menu = 'green|chai|oolong';
|
|
1899
|
+
assert.isNotArray(menu, 'what kind of tea do we want?');
|
|
1900
|
+
|
|
1901
|
+
@name isNotArray
|
|
1902
|
+
@param {Mixed} value
|
|
1903
|
+
@param {String} message
|
|
1904
|
+
@api public
|
|
1905
|
+
/</span>
|
|
1906
|
+
|
|
1907
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotArray</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1908
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">'array'</span>);
|
|
1909
|
+
};
|
|
1910
|
+
|
|
1911
|
+
<span class="ruby-node">/**
|
|
1912
|
+
### .isString(value, [message])
|
|
1913
|
+
|
|
1914
|
+
Asserts that `value` is a string.
|
|
1915
|
+
|
|
1916
|
+
var teaOrder = 'chai';
|
|
1917
|
+
assert.isString(teaOrder, 'order placed');
|
|
1918
|
+
|
|
1919
|
+
@name isString
|
|
1920
|
+
@param {Mixed} value
|
|
1921
|
+
@param {String} message
|
|
1922
|
+
@api public
|
|
1923
|
+
/</span>
|
|
1924
|
+
|
|
1925
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isString</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1926
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'string'</span>);
|
|
1927
|
+
};
|
|
1928
|
+
|
|
1929
|
+
<span class="ruby-node">/**
|
|
1930
|
+
### .isNotString(value, [message])
|
|
1931
|
+
|
|
1932
|
+
Asserts that `value` is _not_ a string.
|
|
1933
|
+
|
|
1934
|
+
var teaOrder = 4;
|
|
1935
|
+
assert.isNotString(teaOrder, 'order placed');
|
|
1936
|
+
|
|
1937
|
+
@name isNotString
|
|
1938
|
+
@param {Mixed} value
|
|
1939
|
+
@param {String} message
|
|
1940
|
+
@api public
|
|
1941
|
+
/</span>
|
|
1942
|
+
|
|
1943
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotString</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1944
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'string'</span>);
|
|
1945
|
+
};
|
|
1946
|
+
|
|
1947
|
+
<span class="ruby-node">/**
|
|
1948
|
+
### .isNumber(value, [message])
|
|
1949
|
+
|
|
1950
|
+
Asserts that `value` is a number.
|
|
1951
|
+
|
|
1952
|
+
var cups = 2;
|
|
1953
|
+
assert.isNumber(cups, 'how many cups');
|
|
1954
|
+
|
|
1955
|
+
@name isNumber
|
|
1956
|
+
@param {Number} value
|
|
1957
|
+
@param {String} message
|
|
1958
|
+
@api public
|
|
1959
|
+
/</span>
|
|
1960
|
+
|
|
1961
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNumber</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1962
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'number'</span>);
|
|
1963
|
+
};
|
|
1964
|
+
|
|
1965
|
+
<span class="ruby-node">/**
|
|
1966
|
+
### .isNotNumber(value, [message])
|
|
1967
|
+
|
|
1968
|
+
Asserts that `value` is _not_ a number.
|
|
1969
|
+
|
|
1970
|
+
var cups = '2 cups please';
|
|
1971
|
+
assert.isNotNumber(cups, 'how many cups');
|
|
1972
|
+
|
|
1973
|
+
@name isNotNumber
|
|
1974
|
+
@param {Mixed} value
|
|
1975
|
+
@param {String} message
|
|
1976
|
+
@api public
|
|
1977
|
+
/</span>
|
|
1978
|
+
|
|
1979
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotNumber</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
1980
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'number'</span>);
|
|
1981
|
+
};
|
|
1982
|
+
|
|
1983
|
+
<span class="ruby-node">/**
|
|
1984
|
+
### .isBoolean(value, [message])
|
|
1985
|
+
|
|
1986
|
+
Asserts that `value` is a boolean.
|
|
1987
|
+
|
|
1988
|
+
var teaReady = true
|
|
1989
|
+
, teaServed = false;
|
|
1990
|
+
|
|
1991
|
+
assert.isBoolean(teaReady, 'is the tea ready');
|
|
1992
|
+
assert.isBoolean(teaServed, 'has tea been served');
|
|
1993
|
+
|
|
1994
|
+
@name isBoolean
|
|
1995
|
+
@param {Mixed} value
|
|
1996
|
+
@param {String} message
|
|
1997
|
+
@api public
|
|
1998
|
+
/</span>
|
|
1999
|
+
|
|
2000
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isBoolean</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
2001
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'boolean'</span>);
|
|
2002
|
+
};
|
|
2003
|
+
|
|
2004
|
+
<span class="ruby-node">/**
|
|
2005
|
+
### .isNotBoolean(value, [message])
|
|
2006
|
+
|
|
2007
|
+
Asserts that `value` is _not_ a boolean.
|
|
2008
|
+
|
|
2009
|
+
var teaReady = 'yep'
|
|
2010
|
+
, teaServed = 'nope';
|
|
2011
|
+
|
|
2012
|
+
assert.isNotBoolean(teaReady, 'is the tea ready');
|
|
2013
|
+
assert.isNotBoolean(teaServed, 'has tea been served');
|
|
2014
|
+
|
|
2015
|
+
@name isNotBoolean
|
|
2016
|
+
@param {Mixed} value
|
|
2017
|
+
@param {String} message
|
|
2018
|
+
@api public
|
|
2019
|
+
/</span>
|
|
2020
|
+
|
|
2021
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotBoolean</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
|
|
2022
|
+
<span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">'boolean'</span>);
|
|
2023
|
+
};
|
|
2024
|
+
|
|
2025
|
+
<span class="ruby-node">/**
|
|
2026
|
+
### .typeOf(value, name, [message])
|
|
2027
|
+
|
|
2028
|
+
Asserts that `value`'s type is `name`, as determined by
|
|
2029
|
+
`Object.prototype.toString`.
|
|
2030
|
+
|
|
2031
|
+
assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
|
|
2032
|
+
assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
|
|
2033
|
+
assert.typeOf('tea', 'string', 'we have a string');
|
|
2034
|
+
assert.typeOf(/</span><span class="ruby-identifier">tea</span><span class="ruby-operator">/</span>, <span class="ruby-string">'regexp'</span>, <span class="ruby-string">'we have a regular expression'</span>);
|
|
2035
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">typeOf</span>(<span class="ruby-identifier">null</span>, <span class="ruby-string">'null'</span>, <span class="ruby-string">'we have a null'</span>);
|
|
2036
|
+
<span class="ruby-identifier">assert</span>.<span class="ruby-identifier">typeOf</span>(<span class="ruby-identifier">undefined</span>, <span class="ruby-string">'undefined'</span>, <span class="ruby-string">'we have an undefined'</span>);
|
|
2037
|
+
|
|
2038
|
+
<span class="ruby-ivar">@name</span> <span class="ruby-identifier">typeOf</span>
|
|
2039
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">Mixed</span>} <span class="ruby-identifier">value</span>
|
|
2040
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
|
|
2041
|
+
<span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span>
|
|
2042
|
+
<span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
|
|
2043
|
+
<span class="ruby-regexp">/
|
|
2044
|
+
|
|
2045
|
+
assert.typeOf = function(val, type, msg) {
|
|
2046
|
+
new Assertion(val, msg).to.be.a(type);
|
|
2047
|
+
};
|
|
2048
|
+
|
|
2049
|
+
/</span><span class="ruby-operator">**</span>
|
|
2050
|
+
<span class="ruby-comment">### .notTypeOf(value, name, [message])</span>
|
|
2051
|
+
|
|
2052
|
+
<span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-value">%xvalue`</span><span class="ruby-string">'s type is _not_ `name`, as determined by
|
|
2053
|
+
`Object.prototype.toString`.
|
|
2054
|
+
|
|
2055
|
+
assert.notTypeOf('</span><span class="ruby-identifier">tea</span><span class="ruby-string">', '</span><span class="ruby-identifier">number</span><span class="ruby-string">', '</span><span class="ruby-identifier">strings</span> <span class="ruby-identifier">are</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">numbers</span><span class="ruby-string">');
|
|
2056
|
+
|
|
2057
|
+
@name notTypeOf
|
|
2058
|
+
@param {Mixed} value
|
|
2059
|
+
@param {String} typeof name
|
|
2060
|
+
@param {String} message
|
|
2061
|
+
@api public
|
|
2062
|
+
/
|
|
2063
|
+
|
|
2064
|
+
assert.notTypeOf = function(val, type, msg) {
|
|
2065
|
+
new Assertion(val, msg).to.not.be.a(type);
|
|
2066
|
+
};
|
|
2067
|
+
|
|
2068
|
+
/**
|
|
2069
|
+
### .instanceOf(object, constructor, [message])
|
|
2070
|
+
|
|
2071
|
+
Asserts that `value` is an instance of `constructor`.
|
|
2072
|
+
|
|
2073
|
+
var Tea = function (name) { this.name = name; }
|
|
2074
|
+
, chai = new Tea('</span><span class="ruby-identifier">chai</span><span class="ruby-string">');
|
|
2075
|
+
|
|
2076
|
+
assert.instanceOf(chai, Tea, '</span><span class="ruby-identifier">chai</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">instance</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">tea</span><span class="ruby-string">');
|
|
2077
|
+
|
|
2078
|
+
@name instanceOf
|
|
2079
|
+
@param {Object} object
|
|
2080
|
+
@param {Constructor} constructor
|
|
2081
|
+
@param {String} message
|
|
2082
|
+
@api public
|
|
2083
|
+
/
|
|
2084
|
+
|
|
2085
|
+
assert.instanceOf = function(val, type, msg) {
|
|
2086
|
+
new Assertion(val, msg).to.be.instanceOf(type);
|
|
2087
|
+
};
|
|
2088
|
+
|
|
2089
|
+
/**
|
|
2090
|
+
### .notInstanceOf(object, constructor, [message])
|
|
2091
|
+
|
|
2092
|
+
Asserts `value` is not an instance of `constructor`.
|
|
2093
|
+
|
|
2094
|
+
var Tea = function (name) { this.name = name; }
|
|
2095
|
+
, chai = new String('</span><span class="ruby-identifier">chai</span><span class="ruby-string">');
|
|
2096
|
+
|
|
2097
|
+
assert.notInstanceOf(chai, Tea, '</span><span class="ruby-identifier">chai</span> <span class="ruby-identifier">is</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">instance</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">tea</span><span class="ruby-string">');
|
|
2098
|
+
|
|
2099
|
+
@name notInstanceOf
|
|
2100
|
+
@param {Object} object
|
|
2101
|
+
@param {Constructor} constructor
|
|
2102
|
+
@param {String} message
|
|
2103
|
+
@api public
|
|
2104
|
+
/
|
|
2105
|
+
|
|
2106
|
+
assert.notInstanceOf = function(val, type, msg) {
|
|
2107
|
+
new Assertion(val, msg).to.not.be.instanceOf(type);
|
|
2108
|
+
};
|
|
2109
|
+
|
|
2110
|
+
/**
|
|
2111
|
+
### .include(haystack, needle, [message])
|
|
2112
|
+
|
|
2113
|
+
Asserts that `haystack` includes `needle`. Works
|
|
2114
|
+
for strings and arrays.
|
|
2115
|
+
|
|
2116
|
+
assert.include('</span><span class="ruby-identifier">foobar</span><span class="ruby-string">', '</span><span class="ruby-identifier">bar</span><span class="ruby-string">', '</span><span class="ruby-identifier">foobar</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">string</span> <span class="ruby-string">"bar"</span><span class="ruby-string">');
|
|
2117
|
+
assert.include([ 1, 2, 3 ], 3, '</span><span class="ruby-identifier">array</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">value</span><span class="ruby-string">');
|
|
2118
|
+
|
|
2119
|
+
@name include
|
|
2120
|
+
@param {Array|String} haystack
|
|
2121
|
+
@param {Mixed} needle
|
|
2122
|
+
@param {String} message
|
|
2123
|
+
@api public
|
|
2124
|
+
/
|
|
2125
|
+
|
|
2126
|
+
assert.include = function(exp, inc, msg) {
|
|
2127
|
+
var obj = new Assertion(exp, msg);
|
|
2128
|
+
|
|
2129
|
+
if (Array.isArray(exp)) {
|
|
2130
|
+
obj.to.include(inc);
|
|
2131
|
+
} else if ('</span><span class="ruby-identifier">string</span><span class="ruby-string">' === typeof exp) {
|
|
2132
|
+
obj.to.contain.string(inc);
|
|
2133
|
+
}
|
|
2134
|
+
};
|
|
2135
|
+
|
|
2136
|
+
/**
|
|
2137
|
+
### .match(value, regexp, [message])
|
|
2138
|
+
|
|
2139
|
+
Asserts that `value` matches the regular expression `regexp`.
|
|
2140
|
+
|
|
2141
|
+
assert.match('</span><span class="ruby-identifier">foobar</span><span class="ruby-string">', /^foo/, '</span><span class="ruby-identifier">regexp</span> <span class="ruby-identifier">matches</span><span class="ruby-string">');
|
|
2142
|
+
|
|
2143
|
+
@name match
|
|
2144
|
+
@param {Mixed} value
|
|
2145
|
+
@param {RegExp} regexp
|
|
2146
|
+
@param {String} message
|
|
2147
|
+
@api public
|
|
2148
|
+
/
|
|
2149
|
+
|
|
2150
|
+
assert.match = function(exp, re, msg) {
|
|
2151
|
+
new Assertion(exp, msg).to.match(re);
|
|
2152
|
+
};
|
|
2153
|
+
|
|
2154
|
+
/**
|
|
2155
|
+
### .notMatch(value, regexp, [message])
|
|
2156
|
+
|
|
2157
|
+
Asserts that `value` does not match the regular expression `regexp`.
|
|
2158
|
+
|
|
2159
|
+
assert.notMatch('</span><span class="ruby-identifier">foobar</span><span class="ruby-string">', /^foo/, '</span><span class="ruby-identifier">regexp</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">match</span><span class="ruby-string">');
|
|
2160
|
+
|
|
2161
|
+
@name notMatch
|
|
2162
|
+
@param {Mixed} value
|
|
2163
|
+
@param {RegExp} regexp
|
|
2164
|
+
@param {String} message
|
|
2165
|
+
@api public
|
|
2166
|
+
/
|
|
2167
|
+
|
|
2168
|
+
assert.notMatch = function(exp, re, msg) {
|
|
2169
|
+
new Assertion(exp, msg).to.not.match(re);
|
|
2170
|
+
};
|
|
2171
|
+
|
|
2172
|
+
/**
|
|
2173
|
+
### .property(object, property, [message])
|
|
2174
|
+
|
|
2175
|
+
Asserts that `object` has a property named by `property`.
|
|
2176
|
+
|
|
2177
|
+
assert.property({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">tea</span><span class="ruby-string">');
|
|
2178
|
+
|
|
2179
|
+
@name property
|
|
2180
|
+
@param {Object} object
|
|
2181
|
+
@param {String} property
|
|
2182
|
+
@param {String} message
|
|
2183
|
+
@api public
|
|
2184
|
+
/
|
|
2185
|
+
|
|
2186
|
+
assert.property = function(obj, prop, msg) {
|
|
2187
|
+
new Assertion(obj, msg).to.have.property(prop);
|
|
2188
|
+
};
|
|
2189
|
+
|
|
2190
|
+
/**
|
|
2191
|
+
### .notProperty(object, property, [message])
|
|
2192
|
+
|
|
2193
|
+
Asserts that `object` does _not_ have a property named by `property`.
|
|
2194
|
+
|
|
2195
|
+
assert.notProperty({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">coffee</span><span class="ruby-string">');
|
|
2196
|
+
|
|
2197
|
+
@name notProperty
|
|
2198
|
+
@param {Object} object
|
|
2199
|
+
@param {String} property
|
|
2200
|
+
@param {String} message
|
|
2201
|
+
@api public
|
|
2202
|
+
/
|
|
2203
|
+
|
|
2204
|
+
assert.notProperty = function(obj, prop, msg) {
|
|
2205
|
+
new Assertion(obj, msg).to.not.have.property(prop);
|
|
2206
|
+
};
|
|
2207
|
+
|
|
2208
|
+
/**
|
|
2209
|
+
### .deepProperty(object, property, [message])
|
|
2210
|
+
|
|
2211
|
+
Asserts that `object` has a property named by `property`, which can be a
|
|
2212
|
+
string using dot- and bracket-notation for deep reference.
|
|
2213
|
+
|
|
2214
|
+
assert.deepProperty({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">');
|
|
2215
|
+
|
|
2216
|
+
@name deepProperty
|
|
2217
|
+
@param {Object} object
|
|
2218
|
+
@param {String} property
|
|
2219
|
+
@param {String} message
|
|
2220
|
+
@api public
|
|
2221
|
+
/
|
|
2222
|
+
|
|
2223
|
+
assert.deepProperty = function(obj, prop, msg) {
|
|
2224
|
+
new Assertion(obj, msg).to.have.deep.property(prop);
|
|
2225
|
+
};
|
|
2226
|
+
|
|
2227
|
+
/**
|
|
2228
|
+
### .notDeepProperty(object, property, [message])
|
|
2229
|
+
|
|
2230
|
+
Asserts that `object` does _not_ have a property named by `property`, which
|
|
2231
|
+
can be a string using dot- and bracket-notation for deep reference.
|
|
2232
|
+
|
|
2233
|
+
assert.notDeepProperty({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">oolong</span><span class="ruby-string">');
|
|
2234
|
+
|
|
2235
|
+
@name notDeepProperty
|
|
2236
|
+
@param {Object} object
|
|
2237
|
+
@param {String} property
|
|
2238
|
+
@param {String} message
|
|
2239
|
+
@api public
|
|
2240
|
+
/
|
|
2241
|
+
|
|
2242
|
+
assert.notDeepProperty = function(obj, prop, msg) {
|
|
2243
|
+
new Assertion(obj, msg).to.not.have.deep.property(prop);
|
|
2244
|
+
};
|
|
2245
|
+
|
|
2246
|
+
/**
|
|
2247
|
+
### .propertyVal(object, property, value, [message])
|
|
2248
|
+
|
|
2249
|
+
Asserts that `object` has a property named by `property` with value given
|
|
2250
|
+
by `value`.
|
|
2251
|
+
|
|
2252
|
+
assert.propertyVal({ tea: '</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">' }, '</span><span class="ruby-identifier">tea</span><span class="ruby-string">', '</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">');
|
|
2253
|
+
|
|
2254
|
+
@name propertyVal
|
|
2255
|
+
@param {Object} object
|
|
2256
|
+
@param {String} property
|
|
2257
|
+
@param {Mixed} value
|
|
2258
|
+
@param {String} message
|
|
2259
|
+
@api public
|
|
2260
|
+
/
|
|
2261
|
+
|
|
2262
|
+
assert.propertyVal = function(obj, prop, val, msg) {
|
|
2263
|
+
new Assertion(obj, msg).to.have.property(prop, val);
|
|
2264
|
+
};
|
|
2265
|
+
|
|
2266
|
+
/**
|
|
2267
|
+
### .propertyNotVal(object, property, value, [message])
|
|
2268
|
+
|
|
2269
|
+
Asserts that `object` has a property named by `property`, but with a value
|
|
2270
|
+
different from that given by `value`.
|
|
2271
|
+
|
|
2272
|
+
assert.propertyNotVal({ tea: '</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">' }, '</span><span class="ruby-identifier">tea</span><span class="ruby-string">', '</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">bad</span><span class="ruby-string">');
|
|
2273
|
+
|
|
2274
|
+
@name propertyNotVal
|
|
2275
|
+
@param {Object} object
|
|
2276
|
+
@param {String} property
|
|
2277
|
+
@param {Mixed} value
|
|
2278
|
+
@param {String} message
|
|
2279
|
+
@api public
|
|
2280
|
+
/
|
|
2281
|
+
|
|
2282
|
+
assert.propertyNotVal = function(obj, prop, val, msg) {
|
|
2283
|
+
new Assertion(obj, msg).to.not.have.property(prop, val);
|
|
2284
|
+
};
|
|
2285
|
+
|
|
2286
|
+
/**
|
|
2287
|
+
### .deepPropertyVal(object, property, value, [message])
|
|
2288
|
+
|
|
2289
|
+
Asserts that `object` has a property named by `property` with value given
|
|
2290
|
+
by `value`. `property` can use dot- and bracket-notation for deep
|
|
2291
|
+
reference.
|
|
2292
|
+
|
|
2293
|
+
assert.deepPropertyVal({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">', '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">');
|
|
2294
|
+
|
|
2295
|
+
@name deepPropertyVal
|
|
2296
|
+
@param {Object} object
|
|
2297
|
+
@param {String} property
|
|
2298
|
+
@param {Mixed} value
|
|
2299
|
+
@param {String} message
|
|
2300
|
+
@api public
|
|
2301
|
+
/
|
|
2302
|
+
|
|
2303
|
+
assert.deepPropertyVal = function(obj, prop, val, msg) {
|
|
2304
|
+
new Assertion(obj, msg).to.have.deep.property(prop, val);
|
|
2305
|
+
};
|
|
2306
|
+
|
|
2307
|
+
/**
|
|
2308
|
+
### .deepPropertyNotVal(object, property, value, [message])
|
|
2309
|
+
|
|
2310
|
+
Asserts that `object` has a property named by `property`, but with a value
|
|
2311
|
+
different from that given by `value`. `property` can use dot- and
|
|
2312
|
+
bracket-notation for deep reference.
|
|
2313
|
+
|
|
2314
|
+
assert.deepPropertyNotVal({ tea: { green: '</span><span class="ruby-identifier">matcha</span><span class="ruby-string">' }}, '</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">', '</span><span class="ruby-identifier">konacha</span><span class="ruby-string">');
|
|
2315
|
+
|
|
2316
|
+
@name deepPropertyNotVal
|
|
2317
|
+
@param {Object} object
|
|
2318
|
+
@param {String} property
|
|
2319
|
+
@param {Mixed} value
|
|
2320
|
+
@param {String} message
|
|
2321
|
+
@api public
|
|
2322
|
+
/
|
|
2323
|
+
|
|
2324
|
+
assert.deepPropertyNotVal = function(obj, prop, val, msg) {
|
|
2325
|
+
new Assertion(obj, msg).to.not.have.deep.property(prop, val);
|
|
2326
|
+
};
|
|
2327
|
+
|
|
2328
|
+
/**
|
|
2329
|
+
### .lengthOf(object, length, [message])
|
|
2330
|
+
|
|
2331
|
+
Asserts that `object` has a `length` property with the expected value.
|
|
2332
|
+
|
|
2333
|
+
assert.lengthOf([1,2,3], 3, '</span><span class="ruby-identifier">array</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">length</span> <span class="ruby-identifier">of</span> <span class="ruby-value">3</span><span class="ruby-string">');
|
|
2334
|
+
assert.lengthOf('</span><span class="ruby-identifier">foobar</span><span class="ruby-string">', 5, '</span><span class="ruby-identifier">string</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">length</span> <span class="ruby-identifier">of</span> <span class="ruby-value">6</span><span class="ruby-string">');
|
|
2335
|
+
|
|
2336
|
+
@name lengthOf
|
|
2337
|
+
@param {Mixed} object
|
|
2338
|
+
@param {Number} length
|
|
2339
|
+
@param {String} message
|
|
2340
|
+
@api public
|
|
2341
|
+
/
|
|
2342
|
+
|
|
2343
|
+
assert.lengthOf = function(exp, len, msg) {
|
|
2344
|
+
new Assertion(exp, msg).to.have.length(len);
|
|
2345
|
+
};
|
|
2346
|
+
|
|
2347
|
+
/**
|
|
2348
|
+
### .throws(function, [constructor/string/regexp], [string/regexp], [message])
|
|
2349
|
+
|
|
2350
|
+
Asserts that `function` will throw an error that is an instance of
|
|
2351
|
+
`constructor`, or alternately that it will throw an error with message
|
|
2352
|
+
matching `regexp`.
|
|
2353
|
+
|
|
2354
|
+
assert.throw(fn, '</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">throws</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">reference</span> <span class="ruby-identifier">error</span><span class="ruby-string">');
|
|
2355
|
+
assert.throw(fn, /function throws a reference error/);
|
|
2356
|
+
assert.throw(fn, ReferenceError);
|
|
2357
|
+
assert.throw(fn, ReferenceError, '</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">throws</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">reference</span> <span class="ruby-identifier">error</span><span class="ruby-string">');
|
|
2358
|
+
assert.throw(fn, ReferenceError, /function throws a reference error/);
|
|
2359
|
+
|
|
2360
|
+
@name throws
|
|
2361
|
+
@alias throw
|
|
2362
|
+
@alias Throw
|
|
2363
|
+
@param {Function} function
|
|
2364
|
+
@param {ErrorConstructor} constructor
|
|
2365
|
+
@param {RegExp} regexp
|
|
2366
|
+
@param {String} message
|
|
2367
|
+
@see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
|
|
2368
|
+
@api public
|
|
2369
|
+
/
|
|
2370
|
+
|
|
2371
|
+
assert.Throw = function(fn, errt, errs, msg) {
|
|
2372
|
+
if ('</span><span class="ruby-identifier">string</span><span class="ruby-string">' === typeof errt || errt instanceof RegExp) {
|
|
2373
|
+
errs = errt;
|
|
2374
|
+
errt = null;
|
|
2375
|
+
}
|
|
2376
|
+
|
|
2377
|
+
new Assertion(fn, msg).to.Throw(errt, errs);
|
|
2378
|
+
};
|
|
2379
|
+
|
|
2380
|
+
/**
|
|
2381
|
+
### .doesNotThrow(function, [constructor/regexp], [message])
|
|
2382
|
+
|
|
2383
|
+
Asserts that `function` will _not_ throw an error that is an instance of
|
|
2384
|
+
`constructor`, or alternately that it will not throw an error with message
|
|
2385
|
+
matching `regexp`.
|
|
2386
|
+
|
|
2387
|
+
assert.doesNotThrow(fn, Error, '</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">throw</span><span class="ruby-string">');
|
|
2388
|
+
|
|
2389
|
+
@name doesNotThrow
|
|
2390
|
+
@param {Function} function
|
|
2391
|
+
@param {ErrorConstructor} constructor
|
|
2392
|
+
@param {RegExp} regexp
|
|
2393
|
+
@param {String} message
|
|
2394
|
+
@see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
|
|
2395
|
+
@api public
|
|
2396
|
+
/
|
|
2397
|
+
|
|
2398
|
+
assert.doesNotThrow = function(fn, type, msg) {
|
|
2399
|
+
if ('</span><span class="ruby-identifier">string</span><span class="ruby-string">' === typeof type) {
|
|
2400
|
+
msg = type;
|
|
2401
|
+
type = null;
|
|
2402
|
+
}
|
|
2403
|
+
|
|
2404
|
+
new Assertion(fn, msg).to.not.Throw(type);
|
|
2405
|
+
};
|
|
2406
|
+
|
|
2407
|
+
/**
|
|
2408
|
+
### .operator(val1, operator, val2, [message])
|
|
2409
|
+
|
|
2410
|
+
Compares two values using `operator`.
|
|
2411
|
+
|
|
2412
|
+
assert.operator(1, '</span><span class="ruby-operator"><</span><span class="ruby-string">', 2, '</span><span class="ruby-identifier">everything</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">ok</span><span class="ruby-string">');
|
|
2413
|
+
assert.operator(1, '</span><span class="ruby-operator">></span><span class="ruby-string">', 2, '</span><span class="ruby-identifier">this</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">fail</span><span class="ruby-string">');
|
|
2414
|
+
|
|
2415
|
+
@name operator
|
|
2416
|
+
@param {Mixed} val1
|
|
2417
|
+
@param {String} operator
|
|
2418
|
+
@param {Mixed} val2
|
|
2419
|
+
@param {String} message
|
|
2420
|
+
@api public
|
|
2421
|
+
/
|
|
2422
|
+
|
|
2423
|
+
assert.operator = function(val, operator, val2, msg) {
|
|
2424
|
+
if (!~ ['</span><span class="ruby-operator">==</span><span class="ruby-string">', '</span><span class="ruby-operator">===</span><span class="ruby-string">', '</span><span class="ruby-operator">></span><span class="ruby-string">', '</span><span class="ruby-operator">>=</span><span class="ruby-string">', '</span><span class="ruby-operator"><</span><span class="ruby-string">', '</span><span class="ruby-operator"><=</span><span class="ruby-string">', '</span><span class="ruby-operator">!=</span><span class="ruby-string">', '</span><span class="ruby-operator">!=</span>=<span class="ruby-string">'].indexOf(operator)) {
|
|
2425
|
+
throw new Error('</span><span class="ruby-constant">Invalid</span> <span class="ruby-identifier">operator</span> <span class="ruby-string">"' + operator + '"</span><span class="ruby-string">');
|
|
2426
|
+
}
|
|
2427
|
+
var test = new Assertion(eval(val + operator + val2), msg);
|
|
2428
|
+
test.assert(
|
|
2429
|
+
true === flag(test, '</span><span class="ruby-identifier">object</span><span class="ruby-string">'), '</span><span class="ruby-identifier">expected</span> <span class="ruby-string">' + util.inspect(val) + '</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">be</span> <span class="ruby-string">' + operator + '</span> <span class="ruby-string">' + util.inspect(val2), '</span><span class="ruby-identifier">expected</span> <span class="ruby-string">' + util.inspect(val) + '</span> <span class="ruby-identifier">to</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">be</span> <span class="ruby-string">' + operator + '</span> <span class="ruby-string">' + util.inspect(val2));
|
|
2430
|
+
};
|
|
2431
|
+
|
|
2432
|
+
/**
|
|
2433
|
+
### .closeTo(actual, expected, delta, [message])
|
|
2434
|
+
|
|
2435
|
+
Asserts that the target is equal `expected`, to within a +/- `delta` range.
|
|
2436
|
+
|
|
2437
|
+
assert.closeTo(1.5, 1, 0.5, '</span><span class="ruby-identifier">numbers</span> <span class="ruby-identifier">are</span> <span class="ruby-identifier">close</span><span class="ruby-string">');
|
|
2438
|
+
|
|
2439
|
+
@name closeTo
|
|
2440
|
+
@param {Number} actual
|
|
2441
|
+
@param {Number} expected
|
|
2442
|
+
@param {Number} delta
|
|
2443
|
+
@param {String} message
|
|
2444
|
+
@api public
|
|
2445
|
+
/
|
|
2446
|
+
|
|
2447
|
+
assert.closeTo = function(act, exp, delta, msg) {
|
|
2448
|
+
new Assertion(act, msg).to.be.closeTo(exp, delta);
|
|
2449
|
+
};
|
|
2450
|
+
|
|
2451
|
+
/*!
|
|
2452
|
+
Undocumented / untested
|
|
2453
|
+
/
|
|
2454
|
+
|
|
2455
|
+
assert.ifError = function(val, msg) {
|
|
2456
|
+
new Assertion(val, msg).to.not.be.ok;
|
|
2457
|
+
};
|
|
2458
|
+
|
|
2459
|
+
/*!
|
|
2460
|
+
Aliases.
|
|
2461
|
+
/
|
|
2462
|
+
|
|
2463
|
+
(function alias(name, as) {
|
|
2464
|
+
assert[as] = assert[name];
|
|
2465
|
+
return alias;
|
|
2466
|
+
})
|
|
2467
|
+
('</span><span class="ruby-constant">Throw</span><span class="ruby-string">', '</span><span class="ruby-identifier">throw</span><span class="ruby-string">')
|
|
2468
|
+
('</span><span class="ruby-constant">Throw</span><span class="ruby-string">', '</span><span class="ruby-identifier">throws</span><span class="ruby-string">');
|
|
2469
|
+
};
|
|
2470
|
+
|
|
2471
|
+
}); // module: chai/interface/assert.js
|
|
2472
|
+
require.register("chai/interface/expect.js", function(module, exports, require) {
|
|
2473
|
+
/*!
|
|
2474
|
+
chai
|
|
2475
|
+
Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2476
|
+
MIT Licensed
|
|
2477
|
+
/
|
|
2478
|
+
|
|
2479
|
+
module.exports = function(chai, util) {
|
|
2480
|
+
chai.expect = function(val, message) {
|
|
2481
|
+
return new chai.Assertion(val, message);
|
|
2482
|
+
};
|
|
2483
|
+
};
|
|
2484
|
+
|
|
2485
|
+
}); // module: chai/interface/expect.js
|
|
2486
|
+
require.register("chai/interface/should.js", function(module, exports, require) {
|
|
2487
|
+
/*!
|
|
2488
|
+
chai
|
|
2489
|
+
Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2490
|
+
MIT Licensed
|
|
2491
|
+
/
|
|
2492
|
+
|
|
2493
|
+
module.exports = function(chai, util) {
|
|
2494
|
+
var Assertion = chai.Assertion;
|
|
2495
|
+
|
|
2496
|
+
function loadShould() {
|
|
2497
|
+
// modify Object.prototype to have `should`
|
|
2498
|
+
Object.defineProperty(Object.prototype, '</span><span class="ruby-identifier">should</span><span class="ruby-string">', {
|
|
2499
|
+
set: function(value) {
|
|
2500
|
+
// See https://github.com/chaijs/chai/issues/86: this makes
|
|
2501
|
+
// `whatever.should = someValue` actually set `someValue`, which is
|
|
2502
|
+
// especially useful for `global.should = require('</span><span class="ruby-identifier">chai</span><span class="ruby-string">').should()`.
|
|
2503
|
+
//
|
|
2504
|
+
// Note that we have to use [[DefineProperty]] instead of [[Put]]
|
|
2505
|
+
// since otherwise we would trigger this very setter!
|
|
2506
|
+
Object.defineProperty(this, '</span><span class="ruby-identifier">should</span><span class="ruby-string">', {
|
|
2507
|
+
value: value,
|
|
2508
|
+
enumerable: true,
|
|
2509
|
+
configurable: true,
|
|
2510
|
+
writable: true
|
|
2511
|
+
});
|
|
2512
|
+
},
|
|
2513
|
+
get: function() {
|
|
2514
|
+
if (this instanceof String || this instanceof Number) {
|
|
2515
|
+
return new Assertion(this.constructor(this));
|
|
2516
|
+
} else if (this instanceof Boolean) {
|
|
2517
|
+
return new Assertion(this == true);
|
|
2518
|
+
}
|
|
2519
|
+
return new Assertion(this);
|
|
2520
|
+
},
|
|
2521
|
+
configurable: true
|
|
2522
|
+
});
|
|
2523
|
+
|
|
2524
|
+
var should = {};
|
|
2525
|
+
|
|
2526
|
+
should.equal = function(val1, val2, msg) {
|
|
2527
|
+
new Assertion(val1, msg).to.equal(val2);
|
|
2528
|
+
};
|
|
2529
|
+
|
|
2530
|
+
should.Throw = function(fn, errt, errs, msg) {
|
|
2531
|
+
new Assertion(fn, msg).to.Throw(errt, errs);
|
|
2532
|
+
};
|
|
2533
|
+
|
|
2534
|
+
should.exist = function(val, msg) {
|
|
2535
|
+
new Assertion(val, msg).to.exist;
|
|
2536
|
+
}
|
|
2537
|
+
|
|
2538
|
+
// negation
|
|
2539
|
+
should.not = {}
|
|
2540
|
+
|
|
2541
|
+
should.not.equal = function(val1, val2, msg) {
|
|
2542
|
+
new Assertion(val1, msg).to.not.equal(val2);
|
|
2543
|
+
};
|
|
2544
|
+
|
|
2545
|
+
should.not.Throw = function(fn, errt, errs, msg) {
|
|
2546
|
+
new Assertion(fn, msg).to.not.Throw(errt, errs);
|
|
2547
|
+
};
|
|
2548
|
+
|
|
2549
|
+
should.not.exist = function(val, msg) {
|
|
2550
|
+
new Assertion(val, msg).to.not.exist;
|
|
2551
|
+
}
|
|
2552
|
+
|
|
2553
|
+
should['</span><span class="ruby-identifier">throw</span><span class="ruby-string">'] = should['</span><span class="ruby-constant">Throw</span><span class="ruby-string">'];
|
|
2554
|
+
should.not['</span><span class="ruby-identifier">throw</span><span class="ruby-string">'] = should.not['</span><span class="ruby-constant">Throw</span><span class="ruby-string">'];
|
|
2555
|
+
|
|
2556
|
+
return should;
|
|
2557
|
+
};
|
|
2558
|
+
|
|
2559
|
+
chai.should = loadShould;
|
|
2560
|
+
chai.Should = loadShould;
|
|
2561
|
+
};
|
|
2562
|
+
|
|
2563
|
+
}); // module: chai/interface/should.js
|
|
2564
|
+
require.register("chai/utils/addChainableMethod.js", function(module, exports, require) {
|
|
2565
|
+
/*!
|
|
2566
|
+
Chai - addChainingMethod utility
|
|
2567
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2568
|
+
MIT Licensed
|
|
2569
|
+
/
|
|
2570
|
+
|
|
2571
|
+
/*!
|
|
2572
|
+
Module dependencies
|
|
2573
|
+
/
|
|
2574
|
+
|
|
2575
|
+
var transferFlags = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span><span class="ruby-string">');
|
|
2576
|
+
|
|
2577
|
+
/*!
|
|
2578
|
+
Module variables
|
|
2579
|
+
/
|
|
2580
|
+
|
|
2581
|
+
// Check whether `__proto__` is supported
|
|
2582
|
+
var hasProtoSupport = '</span><span class="ruby-identifier">__proto__</span><span class="ruby-string">' in Object;
|
|
2583
|
+
|
|
2584
|
+
// Without `__proto__` support, this module will need to add properties to a function.
|
|
2585
|
+
// However, some Function.prototype methods cannot be overwritten,
|
|
2586
|
+
// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).
|
|
2587
|
+
var excludeNames = /^(?:length|name|arguments|caller)$/;
|
|
2588
|
+
|
|
2589
|
+
/**
|
|
2590
|
+
### addChainableMethod (ctx, name, method, chainingBehavior)
|
|
2591
|
+
|
|
2592
|
+
Adds a method to an object, such that the method can also be chained.
|
|
2593
|
+
|
|
2594
|
+
utils.addChainableMethod(chai.Assertion.prototype, '</span><span class="ruby-identifier">foo</span><span class="ruby-string">', function (str) {
|
|
2595
|
+
var obj = utils.flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">');
|
|
2596
|
+
new chai.Assertion(obj).to.be.equal(str);
|
|
2597
|
+
});
|
|
2598
|
+
|
|
2599
|
+
Can also be accessed directly from `chai.Assertion`.
|
|
2600
|
+
|
|
2601
|
+
chai.Assertion.addChainableMethod('</span><span class="ruby-identifier">foo</span><span class="ruby-string">', fn, chainingBehavior);
|
|
2602
|
+
|
|
2603
|
+
The result can then be used as both a method assertion, executing both `method` and
|
|
2604
|
+
`chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
|
|
2605
|
+
|
|
2606
|
+
expect(fooStr).to.be.foo('</span><span class="ruby-identifier">bar</span><span class="ruby-string">');
|
|
2607
|
+
expect(fooStr).to.be.foo.equal('</span><span class="ruby-identifier">foo</span><span class="ruby-string">');
|
|
2608
|
+
|
|
2609
|
+
@param {Object} ctx object to which the method is added
|
|
2610
|
+
@param {String} name of method to add
|
|
2611
|
+
@param {Function} method function to be used for `name`, when called
|
|
2612
|
+
@param {Function} chainingBehavior function to be called every time the property is accessed
|
|
2613
|
+
@name addChainableMethod
|
|
2614
|
+
@api public
|
|
2615
|
+
/
|
|
2616
|
+
|
|
2617
|
+
module.exports = function(ctx, name, method, chainingBehavior) {
|
|
2618
|
+
if (typeof chainingBehavior !== '</span><span class="ruby-identifier">function</span><span class="ruby-string">') chainingBehavior = function() {};
|
|
2619
|
+
|
|
2620
|
+
Object.defineProperty(ctx, name, {
|
|
2621
|
+
get: function() {
|
|
2622
|
+
chainingBehavior.call(this);
|
|
2623
|
+
|
|
2624
|
+
var assert = function() {
|
|
2625
|
+
var result = method.apply(this, arguments);
|
|
2626
|
+
return result === undefined ? this : result;
|
|
2627
|
+
};
|
|
2628
|
+
|
|
2629
|
+
// Use `__proto__` if available
|
|
2630
|
+
if (hasProtoSupport) {
|
|
2631
|
+
assert.__proto__ = this;
|
|
2632
|
+
}
|
|
2633
|
+
// Otherwise, redefine all properties (slow!)
|
|
2634
|
+
else {
|
|
2635
|
+
var asserterNames = Object.getOwnPropertyNames(ctx);
|
|
2636
|
+
asserterNames.forEach(function(asserterName) {
|
|
2637
|
+
if (!excludeNames.test(asserterName)) {
|
|
2638
|
+
var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
|
|
2639
|
+
Object.defineProperty(assert, asserterName, pd);
|
|
2640
|
+
}
|
|
2641
|
+
});
|
|
2642
|
+
}
|
|
2643
|
+
|
|
2644
|
+
transferFlags(this, assert);
|
|
2645
|
+
return assert;
|
|
2646
|
+
},
|
|
2647
|
+
configurable: true
|
|
2648
|
+
});
|
|
2649
|
+
};
|
|
2650
|
+
|
|
2651
|
+
}); // module: chai/utils/addChainableMethod.js
|
|
2652
|
+
require.register("chai/utils/addMethod.js", function(module, exports, require) {
|
|
2653
|
+
/*!
|
|
2654
|
+
Chai - addMethod utility
|
|
2655
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2656
|
+
MIT Licensed
|
|
2657
|
+
/
|
|
2658
|
+
|
|
2659
|
+
/**
|
|
2660
|
+
### .addMethod (ctx, name, method)
|
|
2661
|
+
|
|
2662
|
+
Adds a method to the prototype of an object.
|
|
2663
|
+
|
|
2664
|
+
utils.addMethod(chai.Assertion.prototype, '</span><span class="ruby-identifier">foo</span><span class="ruby-string">', function (str) {
|
|
2665
|
+
var obj = utils.flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">');
|
|
2666
|
+
new chai.Assertion(obj).to.be.equal(str);
|
|
2667
|
+
});
|
|
2668
|
+
|
|
2669
|
+
Can also be accessed directly from `chai.Assertion`.
|
|
2670
|
+
|
|
2671
|
+
chai.Assertion.addMethod('</span><span class="ruby-identifier">foo</span><span class="ruby-string">', fn);
|
|
2672
|
+
|
|
2673
|
+
Then can be used as any other assertion.
|
|
2674
|
+
|
|
2675
|
+
expect(fooStr).to.be.foo('</span><span class="ruby-identifier">bar</span><span class="ruby-string">');
|
|
2676
|
+
|
|
2677
|
+
@param {Object} ctx object to which the method is added
|
|
2678
|
+
@param {String} name of method to add
|
|
2679
|
+
@param {Function} method function to be used for name
|
|
2680
|
+
@name addMethod
|
|
2681
|
+
@api public
|
|
2682
|
+
/
|
|
2683
|
+
|
|
2684
|
+
module.exports = function(ctx, name, method) {
|
|
2685
|
+
ctx[name] = function() {
|
|
2686
|
+
var result = method.apply(this, arguments);
|
|
2687
|
+
return result === undefined ? this : result;
|
|
2688
|
+
};
|
|
2689
|
+
};
|
|
2690
|
+
|
|
2691
|
+
}); // module: chai/utils/addMethod.js
|
|
2692
|
+
require.register("chai/utils/addProperty.js", function(module, exports, require) {
|
|
2693
|
+
/*!
|
|
2694
|
+
Chai - addProperty utility
|
|
2695
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2696
|
+
MIT Licensed
|
|
2697
|
+
/
|
|
2698
|
+
|
|
2699
|
+
/**
|
|
2700
|
+
### addProperty (ctx, name, getter)
|
|
2701
|
+
|
|
2702
|
+
Adds a property to the prototype of an object.
|
|
2703
|
+
|
|
2704
|
+
utils.addProperty(chai.Assertion.prototype, '</span><span class="ruby-identifier">foo</span><span class="ruby-string">', function () {
|
|
2705
|
+
var obj = utils.flag(this, '</span><span class="ruby-identifier">object</span><span class="ruby-string">');
|
|
2706
|
+
new chai.Assertion(obj).to.be.instanceof(Foo);
|
|
2707
|
+
});
|
|
2708
|
+
|
|
2709
|
+
Can also be accessed directly from `chai.Assertion`.
|
|
2710
|
+
|
|
2711
|
+
chai.Assertion.addProperty('</span><span class="ruby-identifier">foo</span><span class="ruby-string">', fn);
|
|
2712
|
+
|
|
2713
|
+
Then can be used as any other assertion.
|
|
2714
|
+
|
|
2715
|
+
expect(myFoo).to.be.foo;
|
|
2716
|
+
|
|
2717
|
+
@param {Object} ctx object to which the property is added
|
|
2718
|
+
@param {String} name of property to add
|
|
2719
|
+
@param {Function} getter function to be used for name
|
|
2720
|
+
@name addProperty
|
|
2721
|
+
@api public
|
|
2722
|
+
/
|
|
2723
|
+
|
|
2724
|
+
module.exports = function(ctx, name, getter) {
|
|
2725
|
+
Object.defineProperty(ctx, name, {
|
|
2726
|
+
get: function() {
|
|
2727
|
+
var result = getter.call(this);
|
|
2728
|
+
return result === undefined ? this : result;
|
|
2729
|
+
},
|
|
2730
|
+
configurable: true
|
|
2731
|
+
});
|
|
2732
|
+
};
|
|
2733
|
+
|
|
2734
|
+
}); // module: chai/utils/addProperty.js
|
|
2735
|
+
require.register("chai/utils/eql.js", function(module, exports, require) {
|
|
2736
|
+
// This is (almost) directly from Node.js assert
|
|
2737
|
+
// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
|
|
2738
|
+
module.exports = _deepEqual;
|
|
2739
|
+
|
|
2740
|
+
var getEnumerableProperties = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getEnumerableProperties</span><span class="ruby-string">');
|
|
2741
|
+
|
|
2742
|
+
// for the browser
|
|
2743
|
+
var Buffer;
|
|
2744
|
+
try {
|
|
2745
|
+
Buffer = require('</span><span class="ruby-identifier">buffer</span><span class="ruby-string">').Buffer;
|
|
2746
|
+
} catch (ex) {
|
|
2747
|
+
Buffer = {
|
|
2748
|
+
isBuffer: function() {
|
|
2749
|
+
return false;
|
|
2750
|
+
}
|
|
2751
|
+
};
|
|
2752
|
+
}
|
|
2753
|
+
|
|
2754
|
+
function _deepEqual(actual, expected, memos) {
|
|
2755
|
+
|
|
2756
|
+
// 7.1. All identical values are equivalent, as determined by ===.
|
|
2757
|
+
if (actual === expected) {
|
|
2758
|
+
return true;
|
|
2759
|
+
|
|
2760
|
+
} else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
|
|
2761
|
+
if (actual.length != expected.length) return false;
|
|
2762
|
+
|
|
2763
|
+
for (var i = 0; i < actual.length; i++) {
|
|
2764
|
+
if (actual[i] !== expected[i]) return false;
|
|
2765
|
+
}
|
|
2766
|
+
|
|
2767
|
+
return true;
|
|
2768
|
+
|
|
2769
|
+
// 7.2. If the expected value is a Date object, the actual value is
|
|
2770
|
+
// equivalent if it is also a Date object that refers to the same time.
|
|
2771
|
+
} else if (actual instanceof Date && expected instanceof Date) {
|
|
2772
|
+
return actual.getTime() === expected.getTime();
|
|
2773
|
+
|
|
2774
|
+
// 7.3. Other pairs that do not both pass typeof value == '</span><span class="ruby-identifier">object</span><span class="ruby-string">',
|
|
2775
|
+
// equivalence is determined by ==.
|
|
2776
|
+
} else if (typeof actual != '</span><span class="ruby-identifier">object</span><span class="ruby-string">' && typeof expected != '</span><span class="ruby-identifier">object</span><span class="ruby-string">') {
|
|
2777
|
+
return actual === expected;
|
|
2778
|
+
|
|
2779
|
+
// 7.4. For all other Object pairs, including Array objects, equivalence is
|
|
2780
|
+
// determined by having the same number of owned properties (as verified
|
|
2781
|
+
// with Object.prototype.hasOwnProperty.call), the same set of keys
|
|
2782
|
+
// (although not necessarily the same order), equivalent values for every
|
|
2783
|
+
// corresponding key, and an identical '</span><span class="ruby-identifier">prototype</span><span class="ruby-string">' property. Note: this
|
|
2784
|
+
// accounts for both named and indexed properties on Arrays.
|
|
2785
|
+
} else {
|
|
2786
|
+
return objEquiv(actual, expected, memos);
|
|
2787
|
+
}
|
|
2788
|
+
}
|
|
2789
|
+
|
|
2790
|
+
function isUndefinedOrNull(value) {
|
|
2791
|
+
return value === null || value === undefined;
|
|
2792
|
+
}
|
|
2793
|
+
|
|
2794
|
+
function isArguments(object) {
|
|
2795
|
+
return Object.prototype.toString.call(object) == '</span>[<span class="ruby-identifier">object</span> <span class="ruby-constant">Arguments</span>]<span class="ruby-string">';
|
|
2796
|
+
}
|
|
2797
|
+
|
|
2798
|
+
function objEquiv(a, b, memos) {
|
|
2799
|
+
if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false;
|
|
2800
|
+
|
|
2801
|
+
// an identical '</span><span class="ruby-identifier">prototype</span><span class="ruby-string">' property.
|
|
2802
|
+
if (a.prototype !== b.prototype) return false;
|
|
2803
|
+
|
|
2804
|
+
// check if we have already compared a and b
|
|
2805
|
+
var i;
|
|
2806
|
+
if (memos) {
|
|
2807
|
+
for (i = 0; i < memos.length; i++) {
|
|
2808
|
+
if ((memos[i][0] === a && memos[i][1] === b) || (memos[i][0] === b && memos[i][1] === a)) return true;
|
|
2809
|
+
}
|
|
2810
|
+
} else {
|
|
2811
|
+
memos = [];
|
|
2812
|
+
}
|
|
2813
|
+
|
|
2814
|
+
//~~~I'</span><span class="ruby-identifier">ve</span> <span class="ruby-identifier">managed</span> <span class="ruby-identifier">to</span> <span class="ruby-keyword">break</span> <span class="ruby-constant">Object</span>.<span class="ruby-identifier">keys</span> <span class="ruby-identifier">through</span> <span class="ruby-identifier">screwy</span> <span class="ruby-identifier">arguments</span> <span class="ruby-identifier">passing</span>.
|
|
2815
|
+
<span class="ruby-operator">/</span><span class="ruby-regexp">/ Converting to array solves the problem.
|
|
2816
|
+
if (isArguments(a)) {
|
|
2817
|
+
if (!isArguments(b)) {
|
|
2818
|
+
return false;
|
|
2819
|
+
}
|
|
2820
|
+
a = pSlice.call(a);
|
|
2821
|
+
b = pSlice.call(b);
|
|
2822
|
+
return _deepEqual(a, b, memos);
|
|
2823
|
+
}
|
|
2824
|
+
try {
|
|
2825
|
+
var ka = getEnumerableProperties(a),
|
|
2826
|
+
kb = getEnumerableProperties(b),
|
|
2827
|
+
key;
|
|
2828
|
+
} catch (e) { /</span><span class="ruby-operator">/</span><span class="ruby-identifier">happens</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">one</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">string</span> <span class="ruby-identifier">literal</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">other</span> <span class="ruby-identifier">isn</span><span class="ruby-string">'t
|
|
2829
|
+
return false;
|
|
2830
|
+
}
|
|
2831
|
+
|
|
2832
|
+
// having the same number of owned properties (keys incorporates
|
|
2833
|
+
// hasOwnProperty)
|
|
2834
|
+
if (ka.length != kb.length) return false;
|
|
2835
|
+
|
|
2836
|
+
//the same set of keys (although not necessarily the same order),
|
|
2837
|
+
ka.sort();
|
|
2838
|
+
kb.sort();
|
|
2839
|
+
//~~~cheap key test
|
|
2840
|
+
for (i = ka.length - 1; i >= 0; i--) {
|
|
2841
|
+
if (ka[i] != kb[i]) return false;
|
|
2842
|
+
}
|
|
2843
|
+
|
|
2844
|
+
// remember objects we have compared to guard against circular references
|
|
2845
|
+
memos.push([a, b]);
|
|
2846
|
+
|
|
2847
|
+
//equivalent values for every corresponding key, and
|
|
2848
|
+
//~~~possibly expensive deep test
|
|
2849
|
+
for (i = ka.length - 1; i >= 0; i--) {
|
|
2850
|
+
key = ka[i];
|
|
2851
|
+
if (!_deepEqual(a[key], b[key], memos)) return false;
|
|
2852
|
+
}
|
|
2853
|
+
|
|
2854
|
+
return true;
|
|
2855
|
+
}
|
|
2856
|
+
|
|
2857
|
+
}); // module: chai/utils/eql.js
|
|
2858
|
+
require.register("chai/utils/flag.js", function(module, exports, require) {
|
|
2859
|
+
/*!
|
|
2860
|
+
Chai - flag utility
|
|
2861
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2862
|
+
MIT Licensed
|
|
2863
|
+
/
|
|
2864
|
+
|
|
2865
|
+
/**
|
|
2866
|
+
### flag(object ,key, [value])
|
|
2867
|
+
|
|
2868
|
+
Get or set a flag value on an object. If a
|
|
2869
|
+
value is provided it will be set, else it will
|
|
2870
|
+
return the currently set value or `undefined` if
|
|
2871
|
+
the value is not set.
|
|
2872
|
+
|
|
2873
|
+
utils.flag(this, '</span><span class="ruby-identifier">foo</span><span class="ruby-string">', '</span><span class="ruby-identifier">bar</span><span class="ruby-string">'); // setter
|
|
2874
|
+
utils.flag(this, '</span><span class="ruby-identifier">foo</span><span class="ruby-string">'); // getter, returns `bar`
|
|
2875
|
+
|
|
2876
|
+
@param {Object} object (constructed Assertion
|
|
2877
|
+
@param {String} key
|
|
2878
|
+
@param {Mixed} value (optional)
|
|
2879
|
+
@name flag
|
|
2880
|
+
@api private
|
|
2881
|
+
/
|
|
2882
|
+
|
|
2883
|
+
module.exports = function(obj, key, value) {
|
|
2884
|
+
var flags = obj.__flags || (obj.__flags = Object.create(null));
|
|
2885
|
+
if (arguments.length === 3) {
|
|
2886
|
+
flags[key] = value;
|
|
2887
|
+
} else {
|
|
2888
|
+
return flags[key];
|
|
2889
|
+
}
|
|
2890
|
+
};
|
|
2891
|
+
|
|
2892
|
+
}); // module: chai/utils/flag.js
|
|
2893
|
+
require.register("chai/utils/getActual.js", function(module, exports, require) {
|
|
2894
|
+
/*!
|
|
2895
|
+
Chai - getActual utility
|
|
2896
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2897
|
+
MIT Licensed
|
|
2898
|
+
/
|
|
2899
|
+
|
|
2900
|
+
/**
|
|
2901
|
+
# getActual(object, [actual])
|
|
2902
|
+
|
|
2903
|
+
Returns the `actual` value for an Assertion
|
|
2904
|
+
|
|
2905
|
+
@param {Object} object (constructed Assertion)
|
|
2906
|
+
@param {Arguments} chai.Assertion.prototype.assert arguments
|
|
2907
|
+
/
|
|
2908
|
+
|
|
2909
|
+
module.exports = function(obj, args) {
|
|
2910
|
+
var actual = args[4];
|
|
2911
|
+
return '</span><span class="ruby-identifier">undefined</span><span class="ruby-string">' !== typeof actual ? actual : obj._obj;
|
|
2912
|
+
};
|
|
2913
|
+
|
|
2914
|
+
}); // module: chai/utils/getActual.js
|
|
2915
|
+
require.register("chai/utils/getEnumerableProperties.js", function(module, exports, require) {
|
|
2916
|
+
/*!
|
|
2917
|
+
Chai - getEnumerableProperties utility
|
|
2918
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2919
|
+
MIT Licensed
|
|
2920
|
+
/
|
|
2921
|
+
|
|
2922
|
+
/**
|
|
2923
|
+
### .getEnumerableProperties(object)
|
|
2924
|
+
|
|
2925
|
+
This allows the retrieval of enumerable property names of an object,
|
|
2926
|
+
inherited or not.
|
|
2927
|
+
|
|
2928
|
+
@param {Object} object
|
|
2929
|
+
@returns {Array}
|
|
2930
|
+
@name getEnumerableProperties
|
|
2931
|
+
@api public
|
|
2932
|
+
/
|
|
2933
|
+
|
|
2934
|
+
module.exports = function getEnumerableProperties(object) {
|
|
2935
|
+
var result = [];
|
|
2936
|
+
for (var name in object) {
|
|
2937
|
+
result.push(name);
|
|
2938
|
+
}
|
|
2939
|
+
return result;
|
|
2940
|
+
};
|
|
2941
|
+
|
|
2942
|
+
}); // module: chai/utils/getEnumerableProperties.js
|
|
2943
|
+
require.register("chai/utils/getMessage.js", function(module, exports, require) {
|
|
2944
|
+
/*!
|
|
2945
|
+
Chai - message composition utility
|
|
2946
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2947
|
+
MIT Licensed
|
|
2948
|
+
/
|
|
2949
|
+
|
|
2950
|
+
/*!
|
|
2951
|
+
Module dependancies
|
|
2952
|
+
/
|
|
2953
|
+
|
|
2954
|
+
var flag = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">flag</span><span class="ruby-string">'),
|
|
2955
|
+
getActual = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getActual</span><span class="ruby-string">'),
|
|
2956
|
+
inspect = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span><span class="ruby-string">'),
|
|
2957
|
+
objDisplay = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span><span class="ruby-string">');
|
|
2958
|
+
|
|
2959
|
+
/**
|
|
2960
|
+
### .getMessage(object, message, negateMessage)
|
|
2961
|
+
|
|
2962
|
+
Construct the error message based on flags
|
|
2963
|
+
and template tags. Template tags will return
|
|
2964
|
+
a stringified inspection of the object referenced.
|
|
2965
|
+
|
|
2966
|
+
Messsage template tags:
|
|
2967
|
+
- `#{this}` current asserted object
|
|
2968
|
+
- `#{act}` actual value
|
|
2969
|
+
- `#{exp}` expected value
|
|
2970
|
+
|
|
2971
|
+
@param {Object} object (constructed Assertion)
|
|
2972
|
+
@param {Arguments} chai.Assertion.prototype.assert arguments
|
|
2973
|
+
@name getMessage
|
|
2974
|
+
@api public
|
|
2975
|
+
/
|
|
2976
|
+
|
|
2977
|
+
module.exports = function(obj, args) {
|
|
2978
|
+
var negate = flag(obj, '</span><span class="ruby-identifier">negate</span><span class="ruby-string">'),
|
|
2979
|
+
val = flag(obj, '</span><span class="ruby-identifier">object</span><span class="ruby-string">'),
|
|
2980
|
+
expected = args[3],
|
|
2981
|
+
actual = getActual(obj, args),
|
|
2982
|
+
msg = negate ? args[2] : args[1],
|
|
2983
|
+
flagMsg = flag(obj, '</span><span class="ruby-identifier">message</span><span class="ruby-string">');
|
|
2984
|
+
|
|
2985
|
+
msg = msg || '</span><span class="ruby-string">';
|
|
2986
|
+
msg = msg.replace(/#{this}/g, objDisplay(val)).replace(/#{act}/g, objDisplay(actual)).replace(/#{exp}/g, objDisplay(expected));
|
|
2987
|
+
|
|
2988
|
+
return flagMsg ? flagMsg + '</span><span class="ruby-operator">:</span> <span class="ruby-string">' + msg : msg;
|
|
2989
|
+
};
|
|
2990
|
+
|
|
2991
|
+
}); // module: chai/utils/getMessage.js
|
|
2992
|
+
require.register("chai/utils/getName.js", function(module, exports, require) {
|
|
2993
|
+
/*!
|
|
2994
|
+
Chai - getName utility
|
|
2995
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
2996
|
+
MIT Licensed
|
|
2997
|
+
/
|
|
2998
|
+
|
|
2999
|
+
/**
|
|
3000
|
+
# getName(func)
|
|
3001
|
+
|
|
3002
|
+
Gets the name of a function, in a cross-browser way.
|
|
3003
|
+
|
|
3004
|
+
@param {Function} a function (usually a constructor)
|
|
3005
|
+
/
|
|
3006
|
+
|
|
3007
|
+
module.exports = function(func) {
|
|
3008
|
+
if (func.name) return func.name;
|
|
3009
|
+
|
|
3010
|
+
var match = /^\s?function ([^(]*)\(/.exec(func);
|
|
3011
|
+
return match && match[1] ? match[1] : "";
|
|
3012
|
+
};
|
|
3013
|
+
|
|
3014
|
+
}); // module: chai/utils/getName.js
|
|
3015
|
+
require.register("chai/utils/getPathValue.js", function(module, exports, require) {
|
|
3016
|
+
/*!
|
|
3017
|
+
Chai - getPathValue utility
|
|
3018
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3019
|
+
@see https://github.com/logicalparadox/filtr
|
|
3020
|
+
MIT Licensed
|
|
3021
|
+
/
|
|
3022
|
+
|
|
3023
|
+
/**
|
|
3024
|
+
### .getPathValue(path, object)
|
|
3025
|
+
|
|
3026
|
+
This allows the retrieval of values in an
|
|
3027
|
+
object given a string path.
|
|
3028
|
+
|
|
3029
|
+
var obj = {
|
|
3030
|
+
prop1: {
|
|
3031
|
+
arr: ['</span><span class="ruby-identifier">a</span><span class="ruby-string">', '</span><span class="ruby-identifier">b</span><span class="ruby-string">', '</span><span class="ruby-identifier">c</span><span class="ruby-string">']
|
|
3032
|
+
, str: '</span><span class="ruby-constant">Hello</span><span class="ruby-string">'
|
|
3033
|
+
}
|
|
3034
|
+
, prop2: {
|
|
3035
|
+
arr: [ { nested: '</span><span class="ruby-constant">Universe</span><span class="ruby-string">' } ]
|
|
3036
|
+
, str: '</span><span class="ruby-constant">Hello</span> <span class="ruby-identifier">again!</span><span class="ruby-string">'
|
|
3037
|
+
}
|
|
3038
|
+
}
|
|
3039
|
+
|
|
3040
|
+
The following would be the results.
|
|
3041
|
+
|
|
3042
|
+
getPathValue('</span><span class="ruby-identifier">prop1</span>.<span class="ruby-identifier">str</span><span class="ruby-string">', obj); // Hello
|
|
3043
|
+
getPathValue('</span><span class="ruby-identifier">prop1</span>.<span class="ruby-identifier">att</span>[<span class="ruby-value">2</span>]<span class="ruby-string">', obj); // b
|
|
3044
|
+
getPathValue('</span><span class="ruby-identifier">prop2</span>.<span class="ruby-identifier">arr</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">nested</span><span class="ruby-string">', obj); // Universe
|
|
3045
|
+
|
|
3046
|
+
@param {String} path
|
|
3047
|
+
@param {Object} object
|
|
3048
|
+
@returns {Object} value or `undefined`
|
|
3049
|
+
@name getPathValue
|
|
3050
|
+
@api public
|
|
3051
|
+
/
|
|
3052
|
+
|
|
3053
|
+
var getPathValue = module.exports = function(path, obj) {
|
|
3054
|
+
var parsed = parsePath(path);
|
|
3055
|
+
return _getPathValue(parsed, obj);
|
|
3056
|
+
};
|
|
3057
|
+
|
|
3058
|
+
/*!
|
|
3059
|
+
## parsePath(path)
|
|
3060
|
+
|
|
3061
|
+
Helper function used to parse string object
|
|
3062
|
+
paths. Use in conjunction with `_getPathValue`.
|
|
3063
|
+
|
|
3064
|
+
var parsed = parsePath('</span><span class="ruby-identifier">myobject</span>.<span class="ruby-identifier">property</span>.<span class="ruby-identifier">subprop</span><span class="ruby-string">');
|
|
3065
|
+
|
|
3066
|
+
### Paths:
|
|
3067
|
+
|
|
3068
|
+
* Can be as near infinitely deep and nested
|
|
3069
|
+
* Arrays are also valid using the formal `myobject.document[3].property`.
|
|
3070
|
+
|
|
3071
|
+
@param {String} path
|
|
3072
|
+
@returns {Object} parsed
|
|
3073
|
+
@api private
|
|
3074
|
+
/
|
|
3075
|
+
|
|
3076
|
+
function parsePath(path) {
|
|
3077
|
+
var str = path.replace(/\[/g, '</span>.[<span class="ruby-string">'),
|
|
3078
|
+
parts = str.match(/(\\.|[^.]+?)+/g);
|
|
3079
|
+
return parts.map(function(value) {
|
|
3080
|
+
var re = /\[(\d+)\]$/,
|
|
3081
|
+
mArr = re.exec(value)
|
|
3082
|
+
if (mArr) return {
|
|
3083
|
+
i: parseFloat(mArr[1])
|
|
3084
|
+
};
|
|
3085
|
+
else return {
|
|
3086
|
+
p: value
|
|
3087
|
+
};
|
|
3088
|
+
});
|
|
3089
|
+
};
|
|
3090
|
+
|
|
3091
|
+
/*!
|
|
3092
|
+
## _getPathValue(parsed, obj)
|
|
3093
|
+
|
|
3094
|
+
Helper companion function for `.parsePath` that returns
|
|
3095
|
+
the value located at the parsed address.
|
|
3096
|
+
|
|
3097
|
+
var value = getPathValue(parsed, obj);
|
|
3098
|
+
|
|
3099
|
+
@param {Object} parsed definition from `parsePath`.
|
|
3100
|
+
@param {Object} object to search against
|
|
3101
|
+
@returns {Object|Undefined} value
|
|
3102
|
+
@api private
|
|
3103
|
+
/
|
|
3104
|
+
|
|
3105
|
+
function _getPathValue(parsed, obj) {
|
|
3106
|
+
var tmp = obj,
|
|
3107
|
+
res;
|
|
3108
|
+
for (var i = 0, l = parsed.length; i < l; i++) {
|
|
3109
|
+
var part = parsed[i];
|
|
3110
|
+
if (tmp) {
|
|
3111
|
+
if ('</span><span class="ruby-identifier">undefined</span><span class="ruby-string">' !== typeof part.p) tmp = tmp[part.p];
|
|
3112
|
+
else if ('</span><span class="ruby-identifier">undefined</span><span class="ruby-string">' !== typeof part.i) tmp = tmp[part.i];
|
|
3113
|
+
if (i == (l - 1)) res = tmp;
|
|
3114
|
+
} else {
|
|
3115
|
+
res = undefined;
|
|
3116
|
+
}
|
|
3117
|
+
}
|
|
3118
|
+
return res;
|
|
3119
|
+
};
|
|
3120
|
+
|
|
3121
|
+
}); // module: chai/utils/getPathValue.js
|
|
3122
|
+
require.register("chai/utils/getProperties.js", function(module, exports, require) {
|
|
3123
|
+
/*!
|
|
3124
|
+
Chai - getProperties utility
|
|
3125
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3126
|
+
MIT Licensed
|
|
3127
|
+
/
|
|
3128
|
+
|
|
3129
|
+
/**
|
|
3130
|
+
### .getProperties(object)
|
|
3131
|
+
|
|
3132
|
+
This allows the retrieval of property names of an object, enumerable or not,
|
|
3133
|
+
inherited or not.
|
|
3134
|
+
|
|
3135
|
+
@param {Object} object
|
|
3136
|
+
@returns {Array}
|
|
3137
|
+
@name getProperties
|
|
3138
|
+
@api public
|
|
3139
|
+
/
|
|
3140
|
+
|
|
3141
|
+
module.exports = function getProperties(object) {
|
|
3142
|
+
var result = Object.getOwnPropertyNames(subject);
|
|
3143
|
+
|
|
3144
|
+
function addProperty(property) {
|
|
3145
|
+
if (result.indexOf(property) === -1) {
|
|
3146
|
+
result.push(property);
|
|
3147
|
+
}
|
|
3148
|
+
}
|
|
3149
|
+
|
|
3150
|
+
var proto = Object.getPrototypeOf(subject);
|
|
3151
|
+
while (proto !== null) {
|
|
3152
|
+
Object.getOwnPropertyNames(proto).forEach(addProperty);
|
|
3153
|
+
proto = Object.getPrototypeOf(proto);
|
|
3154
|
+
}
|
|
3155
|
+
|
|
3156
|
+
return result;
|
|
3157
|
+
};
|
|
3158
|
+
|
|
3159
|
+
}); // module: chai/utils/getProperties.js
|
|
3160
|
+
require.register("chai/utils/index.js", function(module, exports, require) {
|
|
3161
|
+
/*!
|
|
3162
|
+
chai
|
|
3163
|
+
Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
|
|
3164
|
+
MIT Licensed
|
|
3165
|
+
/
|
|
3166
|
+
|
|
3167
|
+
/*!
|
|
3168
|
+
Main exports
|
|
3169
|
+
/
|
|
3170
|
+
|
|
3171
|
+
var exports = module.exports = {};
|
|
3172
|
+
|
|
3173
|
+
/*!
|
|
3174
|
+
test utility
|
|
3175
|
+
/
|
|
3176
|
+
|
|
3177
|
+
exports.test = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">test</span><span class="ruby-string">');
|
|
3178
|
+
|
|
3179
|
+
/*!
|
|
3180
|
+
type utility
|
|
3181
|
+
/
|
|
3182
|
+
|
|
3183
|
+
exports.type = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">type</span><span class="ruby-string">');
|
|
3184
|
+
|
|
3185
|
+
/*!
|
|
3186
|
+
message utility
|
|
3187
|
+
/
|
|
3188
|
+
|
|
3189
|
+
exports.getMessage = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getMessage</span><span class="ruby-string">');
|
|
3190
|
+
|
|
3191
|
+
/*!
|
|
3192
|
+
actual utility
|
|
3193
|
+
/
|
|
3194
|
+
|
|
3195
|
+
exports.getActual = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getActual</span><span class="ruby-string">');
|
|
3196
|
+
|
|
3197
|
+
/*!
|
|
3198
|
+
Inspect util
|
|
3199
|
+
/
|
|
3200
|
+
|
|
3201
|
+
exports.inspect = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span><span class="ruby-string">');
|
|
3202
|
+
|
|
3203
|
+
/*!
|
|
3204
|
+
Object Display util
|
|
3205
|
+
/
|
|
3206
|
+
|
|
3207
|
+
exports.objDisplay = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span><span class="ruby-string">');
|
|
3208
|
+
|
|
3209
|
+
/*!
|
|
3210
|
+
Flag utility
|
|
3211
|
+
/
|
|
3212
|
+
|
|
3213
|
+
exports.flag = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">flag</span><span class="ruby-string">');
|
|
3214
|
+
|
|
3215
|
+
/*!
|
|
3216
|
+
Flag transferring utility
|
|
3217
|
+
/
|
|
3218
|
+
|
|
3219
|
+
exports.transferFlags = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span><span class="ruby-string">');
|
|
3220
|
+
|
|
3221
|
+
/*!
|
|
3222
|
+
Deep equal utility
|
|
3223
|
+
/
|
|
3224
|
+
|
|
3225
|
+
exports.eql = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">eql</span><span class="ruby-string">');
|
|
3226
|
+
|
|
3227
|
+
/*!
|
|
3228
|
+
Deep path value
|
|
3229
|
+
/
|
|
3230
|
+
|
|
3231
|
+
exports.getPathValue = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getPathValue</span><span class="ruby-string">');
|
|
3232
|
+
|
|
3233
|
+
/*!
|
|
3234
|
+
Function name
|
|
3235
|
+
/
|
|
3236
|
+
|
|
3237
|
+
exports.getName = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getName</span><span class="ruby-string">');
|
|
3238
|
+
|
|
3239
|
+
/*!
|
|
3240
|
+
add Property
|
|
3241
|
+
/
|
|
3242
|
+
|
|
3243
|
+
exports.addProperty = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addProperty</span><span class="ruby-string">');
|
|
3244
|
+
|
|
3245
|
+
/*!
|
|
3246
|
+
add Method
|
|
3247
|
+
/
|
|
3248
|
+
|
|
3249
|
+
exports.addMethod = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addMethod</span><span class="ruby-string">');
|
|
3250
|
+
|
|
3251
|
+
/*!
|
|
3252
|
+
overwrite Property
|
|
3253
|
+
/
|
|
3254
|
+
|
|
3255
|
+
exports.overwriteProperty = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">overwriteProperty</span><span class="ruby-string">');
|
|
3256
|
+
|
|
3257
|
+
/*!
|
|
3258
|
+
overwrite Method
|
|
3259
|
+
/
|
|
3260
|
+
|
|
3261
|
+
exports.overwriteMethod = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">overwriteMethod</span><span class="ruby-string">');
|
|
3262
|
+
|
|
3263
|
+
/*!
|
|
3264
|
+
Add a chainable method
|
|
3265
|
+
/
|
|
3266
|
+
|
|
3267
|
+
exports.addChainableMethod = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addChainableMethod</span><span class="ruby-string">');
|
|
3268
|
+
|
|
3269
|
+
}); // module: chai/utils/index.js
|
|
3270
|
+
require.register("chai/utils/inspect.js", function(module, exports, require) {
|
|
3271
|
+
// This is (almost) directly from Node.js utils
|
|
3272
|
+
// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
|
|
3273
|
+
var getName = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getName</span><span class="ruby-string">');
|
|
3274
|
+
var getProperties = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getProperties</span><span class="ruby-string">');
|
|
3275
|
+
var getEnumerableProperties = require('</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getEnumerableProperties</span><span class="ruby-string">');
|
|
3276
|
+
|
|
3277
|
+
module.exports = inspect;
|
|
3278
|
+
|
|
3279
|
+
/**
|
|
3280
|
+
Echos the value of a value. Trys to print the value out
|
|
3281
|
+
in the best way possible given the different types.
|
|
3282
|
+
|
|
3283
|
+
@param {Object} obj The object to print out.
|
|
3284
|
+
@param {Boolean} showHidden Flag that shows hidden (not enumerable)
|
|
3285
|
+
properties of objects.
|
|
3286
|
+
@param {Number} depth Depth in which to descend in object. Default is 2.
|
|
3287
|
+
@param {Boolean} colors Flag to turn on ANSI escape codes to color the
|
|
3288
|
+
output. Default is false (no coloring).
|
|
3289
|
+
/
|
|
3290
|
+
function inspect(obj, showHidden, depth, colors) {
|
|
3291
|
+
var ctx = {
|
|
3292
|
+
showHidden: showHidden,
|
|
3293
|
+
seen: [],
|
|
3294
|
+
stylize: function(str) {
|
|
3295
|
+
return str;
|
|
3296
|
+
}
|
|
3297
|
+
};
|
|
3298
|
+
return formatValue(ctx, obj, (typeof depth === '</span><span class="ruby-identifier">undefined</span><span class="ruby-string">' ? 2 : depth));
|
|
3299
|
+
}
|
|
3300
|
+
|
|
3301
|
+
// https://gist.github.com/1044128/
|
|
3302
|
+
var getOuterHTML = function(element) {
|
|
3303
|
+
if ('</span><span class="ruby-identifier">outerHTML</span><span class="ruby-string">' in element) return element.outerHTML;
|
|
3304
|
+
var ns = "http://www.w3.org/1999/xhtml";
|
|
3305
|
+
var container = document.createElementNS(ns, '</span><span class="ruby-identifier">_</span><span class="ruby-string">');
|
|
3306
|
+
var elemProto = (window.HTMLElement || window.Element).prototype;
|
|
3307
|
+
var xmlSerializer = new XMLSerializer();
|
|
3308
|
+
var html;
|
|
3309
|
+
if (document.xmlVersion) {
|
|
3310
|
+
return xmlSerializer.serializeToString(element);
|
|
3311
|
+
} else {
|
|
3312
|
+
container.appendChild(element.cloneNode(false));
|
|
3313
|
+
html = container.innerHTML.replace('</span><span class="ruby-operator">></span><span class="ruby-operator"><</span><span class="ruby-string">', '</span><span class="ruby-operator">></span><span class="ruby-string">' + element.innerHTML + '</span><span class="ruby-operator"><</span><span class="ruby-string">');
|
|
3314
|
+
container.innerHTML = '</span><span class="ruby-string">';
|
|
3315
|
+
return html;
|
|
3316
|
+
}
|
|
3317
|
+
};
|
|
3318
|
+
|
|
3319
|
+
// Returns true if object is a DOM element.
|
|
3320
|
+
var isDOMElement = function(object) {
|
|
3321
|
+
if (typeof HTMLElement === '</span><span class="ruby-identifier">object</span><span class="ruby-string">') {
|
|
3322
|
+
return object instanceof HTMLElement;
|
|
3323
|
+
} else {
|
|
3324
|
+
return object && typeof object === '</span><span class="ruby-identifier">object</span><span class="ruby-string">' && object.nodeType === 1 && typeof object.nodeName === '</span><span class="ruby-identifier">string</span><span class="ruby-string">';
|
|
3325
|
+
}
|
|
3326
|
+
};
|
|
3327
|
+
|
|
3328
|
+
function formatValue(ctx, value, recurseTimes) {
|
|
3329
|
+
// Provide a hook for user-specified inspect functions.
|
|
3330
|
+
// Check that value is an object with an inspect function on it
|
|
3331
|
+
if (value && typeof value.inspect === '</span><span class="ruby-identifier">function</span><span class="ruby-string">' &&
|
|
3332
|
+
// Filter out the util module, it'</span><span class="ruby-identifier">s</span> <span class="ruby-identifier">inspect</span> <span class="ruby-identifier">function</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">special</span>
|
|
3333
|
+
<span class="ruby-identifier">value</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-operator">!=</span>= <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-operator">&&</span>
|
|
3334
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Also</span> <span class="ruby-identifier">filter</span> <span class="ruby-identifier">out</span> <span class="ruby-identifier">any</span> <span class="ruby-identifier">prototype</span> <span class="ruby-identifier">objects</span> <span class="ruby-identifier">using</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">circular</span> <span class="ruby-identifier">check</span>.
|
|
3335
|
+
<span class="ruby-operator">!</span>(<span class="ruby-identifier">value</span>.<span class="ruby-identifier">constructor</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">constructor</span>.<span class="ruby-identifier">prototype</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">value</span>)) {
|
|
3336
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">recurseTimes</span>);
|
|
3337
|
+
}
|
|
3338
|
+
|
|
3339
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">Primitive</span> <span class="ruby-identifier">types</span> <span class="ruby-identifier">cannot</span> <span class="ruby-identifier">have</span> <span class="ruby-identifier">properties</span>
|
|
3340
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">primitive</span> = <span class="ruby-identifier">formatPrimitive</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>);
|
|
3341
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">primitive</span>) {
|
|
3342
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">primitive</span>;
|
|
3343
|
+
}
|
|
3344
|
+
|
|
3345
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">If</span> <span class="ruby-identifier">it</span><span class="ruby-string">'s DOM elem, get outer HTML.
|
|
3346
|
+
if (isDOMElement(value)) {
|
|
3347
|
+
return getOuterHTML(value);
|
|
3348
|
+
}
|
|
3349
|
+
|
|
3350
|
+
// Look up the keys of the object.
|
|
3351
|
+
var visibleKeys = getEnumerableProperties(value);
|
|
3352
|
+
var keys = ctx.showHidden ? getProperties(value) : visibleKeys;
|
|
3353
|
+
|
|
3354
|
+
// Some type of object without properties can be shortcutted.
|
|
3355
|
+
// In IE, errors have a single `stack` property, or if they are vanilla `Error`,
|
|
3356
|
+
// a `stack` plus `description` property; ignore those for consistency.
|
|
3357
|
+
if (keys.length === 0 || (isError(value) && (
|
|
3358
|
+
(keys.length === 1 && keys[0] === '</span><span class="ruby-identifier">stack</span><span class="ruby-string">') || (keys.length === 2 && keys[0] === '</span><span class="ruby-identifier">description</span><span class="ruby-string">' && keys[1] === '</span><span class="ruby-identifier">stack</span><span class="ruby-string">')))) {
|
|
3359
|
+
if (typeof value === '</span><span class="ruby-identifier">function</span><span class="ruby-string">') {
|
|
3360
|
+
var name = getName(value);
|
|
3361
|
+
var nameSuffix = name ? '</span><span class="ruby-operator">:</span> <span class="ruby-string">' + name : '</span><span class="ruby-string">';
|
|
3362
|
+
return ctx.stylize('</span>[<span class="ruby-constant">Function</span><span class="ruby-string">' + nameSuffix + '</span>]<span class="ruby-string">', '</span><span class="ruby-identifier">special</span><span class="ruby-string">');
|
|
3363
|
+
}
|
|
3364
|
+
if (isRegExp(value)) {
|
|
3365
|
+
return ctx.stylize(RegExp.prototype.toString.call(value), '</span><span class="ruby-identifier">regexp</span><span class="ruby-string">');
|
|
3366
|
+
}
|
|
3367
|
+
if (isDate(value)) {
|
|
3368
|
+
return ctx.stylize(Date.prototype.toUTCString.call(value), '</span><span class="ruby-identifier">date</span><span class="ruby-string">');
|
|
3369
|
+
}
|
|
3370
|
+
if (isError(value)) {
|
|
3371
|
+
return formatError(value);
|
|
3372
|
+
}
|
|
3373
|
+
}
|
|
3374
|
+
|
|
3375
|
+
var base = '</span><span class="ruby-string">',
|
|
3376
|
+
array = false,
|
|
3377
|
+
braces = ['</span>{<span class="ruby-string">', '</span>}<span class="ruby-string">'];
|
|
3378
|
+
|
|
3379
|
+
// Make Array say that they are Array
|
|
3380
|
+
if (isArray(value)) {
|
|
3381
|
+
array = true;
|
|
3382
|
+
braces = ['</span>[<span class="ruby-string">', '</span>]<span class="ruby-string">'];
|
|
3383
|
+
}
|
|
3384
|
+
|
|
3385
|
+
// Make functions say that they are functions
|
|
3386
|
+
if (typeof value === '</span><span class="ruby-identifier">function</span><span class="ruby-string">') {
|
|
3387
|
+
var name = getName(value);
|
|
3388
|
+
var nameSuffix = name ? '</span><span class="ruby-operator">:</span> <span class="ruby-string">' + name : '</span><span class="ruby-string">';
|
|
3389
|
+
base = '</span> [<span class="ruby-constant">Function</span><span class="ruby-string">' + nameSuffix + '</span>]<span class="ruby-string">';
|
|
3390
|
+
}
|
|
3391
|
+
|
|
3392
|
+
// Make RegExps say that they are RegExps
|
|
3393
|
+
if (isRegExp(value)) {
|
|
3394
|
+
base = '</span> <span class="ruby-string">' + RegExp.prototype.toString.call(value);
|
|
3395
|
+
}
|
|
3396
|
+
|
|
3397
|
+
// Make dates with properties first say the date
|
|
3398
|
+
if (isDate(value)) {
|
|
3399
|
+
base = '</span> <span class="ruby-string">' + Date.prototype.toUTCString.call(value);
|
|
3400
|
+
}
|
|
3401
|
+
|
|
3402
|
+
// Make error with message first say the error
|
|
3403
|
+
if (isError(value)) {
|
|
3404
|
+
return formatError(value);
|
|
3405
|
+
}
|
|
3406
|
+
|
|
3407
|
+
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
3408
|
+
return braces[0] + base + braces[1];
|
|
3409
|
+
}
|
|
3410
|
+
|
|
3411
|
+
if (recurseTimes < 0) {
|
|
3412
|
+
if (isRegExp(value)) {
|
|
3413
|
+
return ctx.stylize(RegExp.prototype.toString.call(value), '</span><span class="ruby-identifier">regexp</span><span class="ruby-string">');
|
|
3414
|
+
} else {
|
|
3415
|
+
return ctx.stylize('</span>[<span class="ruby-constant">Object</span>]<span class="ruby-string">', '</span><span class="ruby-identifier">special</span><span class="ruby-string">');
|
|
3416
|
+
}
|
|
3417
|
+
}
|
|
3418
|
+
|
|
3419
|
+
ctx.seen.push(value);
|
|
3420
|
+
|
|
3421
|
+
var output;
|
|
3422
|
+
if (array) {
|
|
3423
|
+
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
3424
|
+
} else {
|
|
3425
|
+
output = keys.map(function(key) {
|
|
3426
|
+
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
3427
|
+
});
|
|
3428
|
+
}
|
|
3429
|
+
|
|
3430
|
+
ctx.seen.pop();
|
|
3431
|
+
|
|
3432
|
+
return reduceToSingleString(output, base, braces);
|
|
3433
|
+
}
|
|
3434
|
+
|
|
3435
|
+
function formatPrimitive(ctx, value) {
|
|
3436
|
+
switch (typeof value) {
|
|
3437
|
+
case '</span><span class="ruby-identifier">undefined</span><span class="ruby-string">':
|
|
3438
|
+
return ctx.stylize('</span><span class="ruby-identifier">undefined</span><span class="ruby-string">', '</span><span class="ruby-identifier">undefined</span><span class="ruby-string">');
|
|
3439
|
+
|
|
3440
|
+
case '</span><span class="ruby-identifier">string</span><span class="ruby-string">':
|
|
3441
|
+
var simple = '</span>\<span class="ruby-string">''</span> <span class="ruby-operator">+</span> <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">stringify</span>(<span class="ruby-identifier">value</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/^"|"$/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">''</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/'/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">"\\'"</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/\"/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">'"'</span>) <span class="ruby-operator">+</span> <span class="ruby-string">'\'</span>;
|
|
3442
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">simple</span>, <span class="ruby-string">'string'</span>);
|
|
3443
|
+
|
|
3444
|
+
<span class="ruby-keyword">case</span> <span class="ruby-string">'number'</span><span class="ruby-operator">:</span>
|
|
3445
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">''</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>, <span class="ruby-string">'number'</span>);
|
|
3446
|
+
|
|
3447
|
+
<span class="ruby-keyword">case</span> <span class="ruby-string">'boolean'</span><span class="ruby-operator">:</span>
|
|
3448
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">''</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>, <span class="ruby-string">'boolean'</span>);
|
|
3449
|
+
}
|
|
3450
|
+
<span class="ruby-regexp">//</span> <span class="ruby-constant">For</span> <span class="ruby-identifier">some</span> <span class="ruby-identifier">reason</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">null</span> <span class="ruby-identifier">is</span> <span class="ruby-string">"object"</span>, <span class="ruby-identifier">so</span> <span class="ruby-identifier">special</span> <span class="ruby-keyword">case</span> <span class="ruby-identifier">here</span>.
|
|
3451
|
+
<span class="ruby-identifier">if</span> (<span class="ruby-identifier">value</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) {
|
|
3452
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">'null'</span>, <span class="ruby-string">'null'</span>);
|
|
3453
|
+
}
|
|
3454
|
+
}
|
|
3455
|
+
|
|
3456
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">formatError</span>(<span class="ruby-identifier">value</span>) {
|
|
3457
|
+
<span class="ruby-keyword">return</span> <span class="ruby-string">'['</span> <span class="ruby-operator">+</span> <span class="ruby-constant">Error</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>) <span class="ruby-operator">+</span> <span class="ruby-string">']'</span>;
|
|
3458
|
+
}
|
|
3459
|
+
|
|
3460
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">formatArray</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">keys</span>) {
|
|
3461
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">output</span> = [];
|
|
3462
|
+
<span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">l</span> = <span class="ruby-identifier">value</span>.<span class="ruby-identifier">length</span>; <span class="ruby-identifier">i</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">l</span>; <span class="ruby-operator">+</span><span class="ruby-operator">+</span><span class="ruby-identifier">i</span>) {
|
|
3463
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">hasOwnProperty</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>, <span class="ruby-constant">String</span>(<span class="ruby-identifier">i</span>))) {
|
|
3464
|
+
<span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-constant">String</span>(<span class="ruby-identifier">i</span>), <span class="ruby-keyword">true</span>));
|
|
3465
|
+
} <span class="ruby-keyword">else</span> {
|
|
3466
|
+
<span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-string">''</span>);
|
|
3467
|
+
}
|
|
3468
|
+
}
|
|
3469
|
+
<span class="ruby-identifier">keys</span>.<span class="ruby-identifier">forEach</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
|
|
3470
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">key</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^\d+$/</span>)) {
|
|
3471
|
+
<span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">key</span>, <span class="ruby-keyword">true</span>));
|
|
3472
|
+
}
|
|
3473
|
+
});
|
|
3474
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">output</span>;
|
|
3475
|
+
}
|
|
3476
|
+
|
|
3477
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">key</span>, <span class="ruby-identifier">array</span>) {
|
|
3478
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">name</span>, <span class="ruby-identifier">str</span>;
|
|
3479
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupGetter__</span>) {
|
|
3480
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupGetter__</span>(<span class="ruby-identifier">key</span>)) {
|
|
3481
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupSetter__</span>(<span class="ruby-identifier">key</span>)) {
|
|
3482
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">'[Getter/Setter]'</span>, <span class="ruby-string">'special'</span>);
|
|
3483
|
+
} <span class="ruby-keyword">else</span> {
|
|
3484
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">'[Getter]'</span>, <span class="ruby-string">'special'</span>);
|
|
3485
|
+
}
|
|
3486
|
+
} <span class="ruby-keyword">else</span> {
|
|
3487
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupSetter__</span>(<span class="ruby-identifier">key</span>)) {
|
|
3488
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">'[Setter]'</span>, <span class="ruby-string">'special'</span>);
|
|
3489
|
+
}
|
|
3490
|
+
}
|
|
3491
|
+
}
|
|
3492
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">visibleKeys</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">key</span>) <span class="ruby-operator"><</span> <span class="ruby-value">0</span>) {
|
|
3493
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-string">'['</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">key</span> <span class="ruby-operator">+</span> <span class="ruby-string">']'</span>;
|
|
3494
|
+
}
|
|
3495
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">str</span>) {
|
|
3496
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">seen</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>]) <span class="ruby-operator"><</span> <span class="ruby-value">0</span>) {
|
|
3497
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">recurseTimes</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) {
|
|
3498
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">formatValue</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>], <span class="ruby-identifier">null</span>);
|
|
3499
|
+
} <span class="ruby-keyword">else</span> {
|
|
3500
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">formatValue</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>], <span class="ruby-identifier">recurseTimes</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>);
|
|
3501
|
+
}
|
|
3502
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">str</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-string">'\n'</span>) <span class="ruby-operator">></span> <span class="ruby-value">-1</span>) {
|
|
3503
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">array</span>) {
|
|
3504
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">str</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">'\n'</span>).<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">line</span>) {
|
|
3505
|
+
<span class="ruby-keyword">return</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">line</span>;
|
|
3506
|
+
}).<span class="ruby-identifier">join</span>(<span class="ruby-string">'\n'</span>).<span class="ruby-identifier">substr</span>(<span class="ruby-value">2</span>);
|
|
3507
|
+
} <span class="ruby-keyword">else</span> {
|
|
3508
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-string">'\n'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">'\n'</span>).<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">line</span>) {
|
|
3509
|
+
<span class="ruby-keyword">return</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">line</span>;
|
|
3510
|
+
}).<span class="ruby-identifier">join</span>(<span class="ruby-string">'\n'</span>);
|
|
3511
|
+
}
|
|
3512
|
+
}
|
|
3513
|
+
} <span class="ruby-keyword">else</span> {
|
|
3514
|
+
<span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">'[Circular]'</span>, <span class="ruby-string">'special'</span>);
|
|
3515
|
+
}
|
|
3516
|
+
}
|
|
3517
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">===</span> <span class="ruby-string">'undefined'</span>) {
|
|
3518
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">array</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^\d+$/</span>)) {
|
|
3519
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
|
|
3520
|
+
}
|
|
3521
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">stringify</span>(<span class="ruby-string">''</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">key</span>);
|
|
3522
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">name</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/</span>)) {
|
|
3523
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">substr</span>(<span class="ruby-value">1</span>, <span class="ruby-identifier">name</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">2</span>);
|
|
3524
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">name</span>, <span class="ruby-string">'name'</span>);
|
|
3525
|
+
} <span class="ruby-keyword">else</span> {
|
|
3526
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/'/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">"\\'"</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/\"/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">'"'</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/(^"|"$)/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">"'"</span>);
|
|
3527
|
+
<span class="ruby-identifier">name</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">name</span>, <span class="ruby-string">'string'</span>);
|
|
3528
|
+
}
|
|
3529
|
+
}
|
|
3530
|
+
|
|
3531
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">+</span> <span class="ruby-string">': '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
|
|
3532
|
+
}
|
|
3533
|
+
|
|
3534
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">reduceToSingleString</span>(<span class="ruby-identifier">output</span>, <span class="ruby-identifier">base</span>, <span class="ruby-identifier">braces</span>) {
|
|
3535
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">numLinesEst</span> = <span class="ruby-value">0</span>;
|
|
3536
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">length</span> = <span class="ruby-identifier">output</span>.<span class="ruby-identifier">reduce</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">prev</span>, <span class="ruby-identifier">cur</span>) {
|
|
3537
|
+
<span class="ruby-identifier">numLinesEst</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>;
|
|
3538
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">cur</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-string">'\n'</span>) <span class="ruby-operator">>=</span> <span class="ruby-value">0</span>) <span class="ruby-identifier">numLinesEst</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>;
|
|
3539
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">prev</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>;
|
|
3540
|
+
}, <span class="ruby-value">0</span>);
|
|
3541
|
+
|
|
3542
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">length</span> <span class="ruby-operator">></span> <span class="ruby-value">60</span>) {
|
|
3543
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> (<span class="ruby-identifier">base</span> <span class="ruby-operator">===</span> <span class="ruby-string">''</span> <span class="ruby-operator">?</span> <span class="ruby-string">''</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">base</span> <span class="ruby-operator">+</span> <span class="ruby-string">'\n '</span>) <span class="ruby-operator">+</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">output</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">',\n '</span>) <span class="ruby-operator">+</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">1</span>];
|
|
3544
|
+
}
|
|
3545
|
+
|
|
3546
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> <span class="ruby-identifier">base</span> <span class="ruby-operator">+</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">output</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">', '</span>) <span class="ruby-operator">+</span> <span class="ruby-string">' '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">1</span>];
|
|
3547
|
+
}
|
|
3548
|
+
|
|
3549
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">isArray</span>(<span class="ruby-identifier">ar</span>) {
|
|
3550
|
+
<span class="ruby-keyword">return</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">isArray</span>(<span class="ruby-identifier">ar</span>) <span class="ruby-operator">||</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">ar</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">ar</span>) <span class="ruby-operator">===</span> <span class="ruby-string">'[object Array]'</span>);
|
|
3551
|
+
}
|
|
3552
|
+
|
|
3553
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">isRegExp</span>(<span class="ruby-identifier">re</span>) {
|
|
3554
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">re</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">re</span>) <span class="ruby-operator">===</span> <span class="ruby-string">'[object RegExp]'</span>;
|
|
3555
|
+
}
|
|
3556
|
+
|
|
3557
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">isDate</span>(<span class="ruby-identifier">d</span>) {
|
|
3558
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">d</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">d</span>) <span class="ruby-operator">===</span> <span class="ruby-string">'[object Date]'</span>;
|
|
3559
|
+
}
|
|
3560
|
+
|
|
3561
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">isError</span>(<span class="ruby-identifier">e</span>) {
|
|
3562
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">e</span> <span class="ruby-operator">===</span> <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">e</span>) <span class="ruby-operator">===</span> <span class="ruby-string">'[object Error]'</span>;
|
|
3563
|
+
}
|
|
3564
|
+
|
|
3565
|
+
<span class="ruby-identifier">function</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">o</span>) {
|
|
3566
|
+
<span class="ruby-keyword">return</span> <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">o</span>);
|
|
3567
|
+
}
|
|
3568
|
+
|
|
3569
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span>.<span class="ruby-identifier">js</span>
|
|
3570
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/objDisplay.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3571
|
+
<span class="ruby-regexp">/*!
|
|
3572
|
+
Chai - flag utility
|
|
3573
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3574
|
+
MIT Licensed
|
|
3575
|
+
/</span>
|
|
3576
|
+
|
|
3577
|
+
<span class="ruby-regexp">/*!
|
|
3578
|
+
Module dependancies
|
|
3579
|
+
/</span>
|
|
3580
|
+
|
|
3581
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">inspect</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./inspect'</span>);
|
|
3582
|
+
|
|
3583
|
+
<span class="ruby-node">/**
|
|
3584
|
+
### .objDisplay (object)
|
|
3585
|
+
|
|
3586
|
+
Determines if an object or an array matches
|
|
3587
|
+
criteria to be inspected in-line for error
|
|
3588
|
+
messages or should be truncated.
|
|
3589
|
+
|
|
3590
|
+
@param {Mixed} javascript object to inspect
|
|
3591
|
+
@name objDisplay
|
|
3592
|
+
@api public
|
|
3593
|
+
/</span>
|
|
3594
|
+
|
|
3595
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>) {
|
|
3596
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">str</span> = <span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">obj</span>),
|
|
3597
|
+
<span class="ruby-identifier">type</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
|
|
3598
|
+
|
|
3599
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">str</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">>=</span> <span class="ruby-value">40</span>) {
|
|
3600
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">'[object Function]'</span>) {
|
|
3601
|
+
<span class="ruby-keyword">return</span> <span class="ruby-operator">!</span><span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">===</span> <span class="ruby-string">''</span> <span class="ruby-operator">?</span> <span class="ruby-string">'[Function]'</span> <span class="ruby-operator">:</span> <span class="ruby-string">'[Function: '</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">+</span> <span class="ruby-string">']'</span>;
|
|
3602
|
+
} <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">'[object Array]'</span>) {
|
|
3603
|
+
<span class="ruby-keyword">return</span> <span class="ruby-string">'[ Array('</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> <span class="ruby-string">') ]'</span>;
|
|
3604
|
+
} <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">'[object Object]'</span>) {
|
|
3605
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">keys</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-identifier">obj</span>),
|
|
3606
|
+
<span class="ruby-identifier">kstr</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">></span> <span class="ruby-value">2</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">splice</span>(<span class="ruby-value">0</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">join</span>(<span class="ruby-string">', '</span>) <span class="ruby-operator">+</span> <span class="ruby-string">', ...'</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">', '</span>);
|
|
3607
|
+
<span class="ruby-keyword">return</span> <span class="ruby-string">'{ Object ('</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">kstr</span> <span class="ruby-operator">+</span> <span class="ruby-string">') }'</span>;
|
|
3608
|
+
} <span class="ruby-keyword">else</span> {
|
|
3609
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
|
|
3610
|
+
}
|
|
3611
|
+
} <span class="ruby-keyword">else</span> {
|
|
3612
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
|
|
3613
|
+
}
|
|
3614
|
+
};
|
|
3615
|
+
|
|
3616
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span>.<span class="ruby-identifier">js</span>
|
|
3617
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/overwriteMethod.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3618
|
+
<span class="ruby-regexp">/*!
|
|
3619
|
+
Chai - overwriteMethod utility
|
|
3620
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3621
|
+
MIT Licensed
|
|
3622
|
+
/</span>
|
|
3623
|
+
|
|
3624
|
+
<span class="ruby-node">/**
|
|
3625
|
+
### overwriteMethod (ctx, name, fn)
|
|
3626
|
+
|
|
3627
|
+
Overwites an already existing method and provides
|
|
3628
|
+
access to previous function. Must return function
|
|
3629
|
+
to be used for name.
|
|
3630
|
+
|
|
3631
|
+
utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {
|
|
3632
|
+
return function (str) {
|
|
3633
|
+
var obj = utils.flag(this, 'object');
|
|
3634
|
+
if (obj instanceof Foo) {
|
|
3635
|
+
new chai.Assertion(obj.value).to.equal(str);
|
|
3636
|
+
} else {
|
|
3637
|
+
_super.apply(this, arguments);
|
|
3638
|
+
}
|
|
3639
|
+
}
|
|
3640
|
+
});
|
|
3641
|
+
|
|
3642
|
+
Can also be accessed directly from `chai.Assertion`.
|
|
3643
|
+
|
|
3644
|
+
chai.Assertion.overwriteMethod('foo', fn);
|
|
3645
|
+
|
|
3646
|
+
Then can be used as any other assertion.
|
|
3647
|
+
|
|
3648
|
+
expect(myFoo).to.equal('bar');
|
|
3649
|
+
|
|
3650
|
+
@param {Object} ctx object whose method is to be overwritten
|
|
3651
|
+
@param {String} name of method to overwrite
|
|
3652
|
+
@param {Function} method function that returns a function to be used for name
|
|
3653
|
+
@name overwriteMethod
|
|
3654
|
+
@api public
|
|
3655
|
+
/</span>
|
|
3656
|
+
|
|
3657
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">method</span>) {
|
|
3658
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">_method</span> = <span class="ruby-identifier">ctx</span>[<span class="ruby-identifier">name</span>],
|
|
3659
|
+
<span class="ruby-identifier">_super</span> = <span class="ruby-identifier">function</span>() {
|
|
3660
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
|
|
3661
|
+
};
|
|
3662
|
+
|
|
3663
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">_method</span> <span class="ruby-operator">&&</span> <span class="ruby-string">'function'</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">_method</span>) <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">_method</span>;
|
|
3664
|
+
|
|
3665
|
+
<span class="ruby-identifier">ctx</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">function</span>() {
|
|
3666
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">result</span> = <span class="ruby-identifier">method</span>(<span class="ruby-identifier">_super</span>).<span class="ruby-identifier">apply</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">arguments</span>);
|
|
3667
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">this</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">result</span>;
|
|
3668
|
+
}
|
|
3669
|
+
};
|
|
3670
|
+
|
|
3671
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">overwriteMethod</span>.<span class="ruby-identifier">js</span>
|
|
3672
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/overwriteProperty.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3673
|
+
<span class="ruby-regexp">/*!
|
|
3674
|
+
Chai - overwriteProperty utility
|
|
3675
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3676
|
+
MIT Licensed
|
|
3677
|
+
/</span>
|
|
3678
|
+
|
|
3679
|
+
<span class="ruby-node">/**
|
|
3680
|
+
### overwriteProperty (ctx, name, fn)
|
|
3681
|
+
|
|
3682
|
+
Overwites an already existing property getter and provides
|
|
3683
|
+
access to previous value. Must return function to use as getter.
|
|
3684
|
+
|
|
3685
|
+
utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {
|
|
3686
|
+
return function () {
|
|
3687
|
+
var obj = utils.flag(this, 'object');
|
|
3688
|
+
if (obj instanceof Foo) {
|
|
3689
|
+
new chai.Assertion(obj.name).to.equal('bar');
|
|
3690
|
+
} else {
|
|
3691
|
+
_super.call(this);
|
|
3692
|
+
}
|
|
3693
|
+
}
|
|
3694
|
+
});
|
|
3695
|
+
|
|
3696
|
+
Can also be accessed directly from `chai.Assertion`.
|
|
3697
|
+
|
|
3698
|
+
chai.Assertion.overwriteProperty('foo', fn);
|
|
3699
|
+
|
|
3700
|
+
Then can be used as any other assertion.
|
|
3701
|
+
|
|
3702
|
+
expect(myFoo).to.be.ok;
|
|
3703
|
+
|
|
3704
|
+
@param {Object} ctx object whose property is to be overwritten
|
|
3705
|
+
@param {String} name of property to overwrite
|
|
3706
|
+
@param {Function} getter function that returns a getter function to be used for name
|
|
3707
|
+
@name overwriteProperty
|
|
3708
|
+
@api public
|
|
3709
|
+
/</span>
|
|
3710
|
+
|
|
3711
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">getter</span>) {
|
|
3712
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">_get</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">getOwnPropertyDescriptor</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>),
|
|
3713
|
+
<span class="ruby-identifier">_super</span> = <span class="ruby-identifier">function</span>() {};
|
|
3714
|
+
|
|
3715
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">_get</span> <span class="ruby-operator">&&</span> <span class="ruby-string">'function'</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">_get</span>.<span class="ruby-identifier">get</span>) <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">_get</span>.<span class="ruby-identifier">get</span>
|
|
3716
|
+
|
|
3717
|
+
<span class="ruby-constant">Object</span>.<span class="ruby-identifier">defineProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, {
|
|
3718
|
+
<span class="ruby-identifier">get</span><span class="ruby-operator">:</span> <span class="ruby-identifier">function</span>() {
|
|
3719
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">result</span> = <span class="ruby-identifier">getter</span>(<span class="ruby-identifier">_super</span>).<span class="ruby-identifier">call</span>(<span class="ruby-identifier">this</span>);
|
|
3720
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">this</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">result</span>;
|
|
3721
|
+
},
|
|
3722
|
+
<span class="ruby-identifier">configurable</span><span class="ruby-operator">:</span> <span class="ruby-keyword">true</span>
|
|
3723
|
+
});
|
|
3724
|
+
};
|
|
3725
|
+
|
|
3726
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">overwriteProperty</span>.<span class="ruby-identifier">js</span>
|
|
3727
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/test.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3728
|
+
<span class="ruby-regexp">/*!
|
|
3729
|
+
Chai - test utility
|
|
3730
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3731
|
+
MIT Licensed
|
|
3732
|
+
/</span>
|
|
3733
|
+
|
|
3734
|
+
<span class="ruby-regexp">/*!
|
|
3735
|
+
Module dependancies
|
|
3736
|
+
/</span>
|
|
3737
|
+
|
|
3738
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">flag</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">'./flag'</span>);
|
|
3739
|
+
|
|
3740
|
+
<span class="ruby-node">/**
|
|
3741
|
+
# test(object, expression)
|
|
3742
|
+
|
|
3743
|
+
Test and object for expression.
|
|
3744
|
+
|
|
3745
|
+
@param {Object} object (constructed Assertion)
|
|
3746
|
+
@param {Arguments} chai.Assertion.prototype.assert arguments
|
|
3747
|
+
/</span>
|
|
3748
|
+
|
|
3749
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">args</span>) {
|
|
3750
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">negate</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-string">'negate'</span>),
|
|
3751
|
+
<span class="ruby-identifier">expr</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>];
|
|
3752
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">negate</span> <span class="ruby-operator">?</span> <span class="ruby-operator">!</span><span class="ruby-identifier">expr</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">expr</span>;
|
|
3753
|
+
};
|
|
3754
|
+
|
|
3755
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">test</span>.<span class="ruby-identifier">js</span>
|
|
3756
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/transferFlags.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3757
|
+
<span class="ruby-regexp">/*!
|
|
3758
|
+
Chai - transferFlags utility
|
|
3759
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3760
|
+
MIT Licensed
|
|
3761
|
+
/</span>
|
|
3762
|
+
|
|
3763
|
+
<span class="ruby-node">/**
|
|
3764
|
+
### transferFlags(assertion, object, includeAll = true)
|
|
3765
|
+
|
|
3766
|
+
Transfer all the flags for `assertion` to `object`. If
|
|
3767
|
+
`includeAll` is set to `false`, then the base Chai
|
|
3768
|
+
assertion flags (namely `object`, `ssfi`, and `message`)
|
|
3769
|
+
will not be transferred.
|
|
3770
|
+
|
|
3771
|
+
var newAssertion = new Assertion();
|
|
3772
|
+
utils.transferFlags(assertion, newAssertion);
|
|
3773
|
+
|
|
3774
|
+
var anotherAsseriton = new Assertion(myObj);
|
|
3775
|
+
utils.transferFlags(assertion, anotherAssertion, false);
|
|
3776
|
+
|
|
3777
|
+
@param {Assertion} assertion the assertion to transfer the flags from
|
|
3778
|
+
@param {Object} object the object to transfer the flags too; usually a new assertion
|
|
3779
|
+
@param {Boolean} includeAll
|
|
3780
|
+
@name getAllFlags
|
|
3781
|
+
@api private
|
|
3782
|
+
/</span>
|
|
3783
|
+
|
|
3784
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">assertion</span>, <span class="ruby-identifier">object</span>, <span class="ruby-identifier">includeAll</span>) {
|
|
3785
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">flags</span> = <span class="ruby-identifier">assertion</span>.<span class="ruby-identifier">__flags</span> <span class="ruby-operator">||</span> (<span class="ruby-identifier">assertion</span>.<span class="ruby-identifier">__flags</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-identifier">null</span>));
|
|
3786
|
+
|
|
3787
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span>) {
|
|
3788
|
+
<span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-identifier">null</span>);
|
|
3789
|
+
}
|
|
3790
|
+
|
|
3791
|
+
<span class="ruby-identifier">includeAll</span> = <span class="ruby-identifier">arguments</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">===</span> <span class="ruby-value">3</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">includeAll</span> <span class="ruby-operator">:</span> <span class="ruby-keyword">true</span>;
|
|
3792
|
+
|
|
3793
|
+
<span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">flag</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">flags</span>) {
|
|
3794
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">includeAll</span> <span class="ruby-operator">||</span> (<span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span>= <span class="ruby-string">'object'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span>= <span class="ruby-string">'ssfi'</span> <span class="ruby-operator">&&</span> <span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span> <span class="ruby-string">'message'</span>)) {
|
|
3795
|
+
<span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span>[<span class="ruby-identifier">flag</span>] = <span class="ruby-identifier">flags</span>[<span class="ruby-identifier">flag</span>];
|
|
3796
|
+
}
|
|
3797
|
+
}
|
|
3798
|
+
};
|
|
3799
|
+
|
|
3800
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span>.<span class="ruby-identifier">js</span>
|
|
3801
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">"chai/utils/type.js"</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
|
|
3802
|
+
<span class="ruby-regexp">/*!
|
|
3803
|
+
Chai - type utility
|
|
3804
|
+
Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
|
|
3805
|
+
MIT Licensed
|
|
3806
|
+
/</span>
|
|
3807
|
+
|
|
3808
|
+
<span class="ruby-regexp">/*!
|
|
3809
|
+
Detectable javascript natives
|
|
3810
|
+
/</span>
|
|
3811
|
+
|
|
3812
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">natives</span> = {
|
|
3813
|
+
<span class="ruby-string">'[object Arguments]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'arguments'</span>,
|
|
3814
|
+
<span class="ruby-string">'[object Array]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'array'</span>,
|
|
3815
|
+
<span class="ruby-string">'[object Date]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'date'</span>,
|
|
3816
|
+
<span class="ruby-string">'[object Function]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'function'</span>,
|
|
3817
|
+
<span class="ruby-string">'[object Number]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'number'</span>,
|
|
3818
|
+
<span class="ruby-string">'[object RegExp]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'regexp'</span>,
|
|
3819
|
+
<span class="ruby-string">'[object String]'</span><span class="ruby-operator">:</span> <span class="ruby-string">'string'</span>
|
|
3820
|
+
};
|
|
3821
|
+
|
|
3822
|
+
<span class="ruby-node">/**
|
|
3823
|
+
### type(object)
|
|
3824
|
+
|
|
3825
|
+
Better implementation of `typeof` detection that can
|
|
3826
|
+
be used cross-browser. Handles the inconsistencies of
|
|
3827
|
+
Array, `null`, and `undefined` detection.
|
|
3828
|
+
|
|
3829
|
+
utils.type({}) /</span><span class="ruby-operator">/</span> <span class="ruby-string">'object'</span>
|
|
3830
|
+
<span class="ruby-identifier">utils</span>.<span class="ruby-identifier">type</span>(<span class="ruby-identifier">null</span>) <span class="ruby-operator">/</span><span class="ruby-regexp">/ `null'
|
|
3831
|
+
utils.type(undefined) /</span><span class="ruby-operator">/</span> <span class="ruby-value">%xundefined`</span>
|
|
3832
|
+
<span class="ruby-identifier">utils</span>.<span class="ruby-identifier">type</span>([]) <span class="ruby-operator">/</span><span class="ruby-regexp">/ `array`
|
|
3833
|
+
|
|
3834
|
+
@param {Mixed} object to detect type of
|
|
3835
|
+
@name type
|
|
3836
|
+
@api private
|
|
3837
|
+
/</span>
|
|
3838
|
+
|
|
3839
|
+
<span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>) {
|
|
3840
|
+
<span class="ruby-identifier">var</span> <span class="ruby-identifier">str</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
|
|
3841
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">natives</span>[<span class="ruby-identifier">str</span>]) <span class="ruby-keyword">return</span> <span class="ruby-identifier">natives</span>[<span class="ruby-identifier">str</span>];
|
|
3842
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) <span class="ruby-keyword">return</span> <span class="ruby-string">'null'</span>;
|
|
3843
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span>) <span class="ruby-keyword">return</span> <span class="ruby-string">'undefined'</span>;
|
|
3844
|
+
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-constant">Object</span>(<span class="ruby-identifier">obj</span>)) <span class="ruby-keyword">return</span> <span class="ruby-string">'object'</span>;
|
|
3845
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">obj</span>;
|
|
3846
|
+
};
|
|
3847
|
+
|
|
3848
|
+
}); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">type</span>.<span class="ruby-identifier">js</span>
|
|
3849
|
+
<span class="ruby-identifier">require</span>.<span class="ruby-identifier">alias</span>(<span class="ruby-string">"./chai.js"</span>, <span class="ruby-string">"chai"</span>);
|
|
3850
|
+
|
|
3851
|
+
<span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-string">'chai'</span>);
|
|
3852
|
+
</pre>
|
|
3853
|
+
|
|
3854
|
+
<p>});</p>
|
|
3855
|
+
</main>
|
|
3856
|
+
|
|
3857
|
+
|
|
3858
|
+
|
|
3859
|
+
<footer id="validator-badges" role="contentinfo">
|
|
3860
|
+
<p><a href="http://validator.w3.org/check/referer">Validate</a>
|
|
3861
|
+
<p>Generated by <a href="http://rdoc.rubyforge.org">RDoc</a> 4.1.0.
|
|
3862
|
+
<p>Based on <a href="http://deveiate.org/projects/Darkfish-Rdoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
|
|
3863
|
+
</footer>
|
|
3864
|
+
|