1
=== modified file 'app/app.js'
2
--- app/app.js	2012-11-20 14:51:46 +0000
3
+++ app/app.js	2012-11-20 23:07:20 +0000
4
@@ -746,6 +746,7 @@
5
746
    'juju-models',
746
    'juju-models',
6
747
    'juju-views',
747
    'juju-views',
7
748
    'juju-controllers',
748
    'juju-controllers',
8
749
    'juju-view-charm-search',
9
749
    'io',
750
    'io',
10
750
    'json-parse',
751
    'json-parse',
11
751
    'app-base',
752
    'app-base',
12
752
753
13
=== modified file 'app/models/charm.js'
14
--- app/models/charm.js	2012-10-29 11:20:31 +0000
15
+++ app/models/charm.js	2012-11-20 23:07:20 +0000
16
@@ -226,6 +226,7 @@
17
226
}, '0.1.0', {
226
}, '0.1.0', {
18
227
  requires: [
227
  requires: [
19
228
    'model',
228
    'model',
21
229
    'model-list'
229
    'model-list',
22
230
    'juju-charm-id'
23
230
  ]
231
  ]
24
231
});
232
});
25
232
233
26
=== modified file 'app/models/models.js'
27
--- app/models/models.js	2012-11-16 08:25:02 +0000
28
+++ app/models/models.js	2012-11-20 23:07:20 +0000
29
@@ -487,6 +487,7 @@
30
487
    'datasource-jsonschema',
487
    'datasource-jsonschema',
31
488
    'io-base',
488
    'io-base',
32
489
    'json-parse',
489
    'json-parse',
33
490
    'juju-endpoints',
34
490
    'juju-view-utils',
491
    'juju-view-utils',
35
491
    'juju-charm-models'
492
    'juju-charm-models'
36
492
  ]
493
  ]
37
493
494
38
=== modified file 'app/modules-debug.js'
39
--- app/modules-debug.js	2012-11-15 15:44:00 +0000
40
+++ app/modules-debug.js	2012-11-20 23:07:20 +0000
41
@@ -1,6 +1,13 @@
42
1
// This file is used for development only. In order to use it you should call
1
// This file is used for development only. In order to use it you should call
43
2
// the "make debug" command. This command passes the "debug" argument to the
2
// the "make debug" command. This command passes the "debug" argument to the
44
3
// "lib/server.js".
3
// "lib/server.js".
45
4
//
46
5
// This file declares which files implement modules, using the
47
6
// "fullpath" property; and declares the membership of rollup modules, using
48
7
// the "use" property to specify what the module name aliases.
49
8
//
50
9
// The "requires" property should not be used here because the javascript
51
10
// minimizer will not parse it.
52
4
var GlobalConfig = {
11
var GlobalConfig = {
53
5
  filter: 'debug',
12
  filter: 'debug',
54
6
  // Set "true" for verbose logging of YUI
13
  // Set "true" for verbose logging of YUI
55
@@ -93,19 +100,15 @@
56
93
        },
100
        },
57
94
101
58
95
        'juju-charm-models': {
102
        'juju-charm-models': {
59
96
          requires: ['juju-charm-id'],
60
97
          fullpath: '/juju-ui/models/charm.js'
103
          fullpath: '/juju-ui/models/charm.js'
61
98
        },
104
        },
62
99
105
63
100
        'juju-models': {
106
        'juju-models': {
64
101
          requires: [
65
102
            'model', 'model-list', 'juju-endpoints', 'juju-charm-models'],
66
103
          fullpath: '/juju-ui/models/models.js'
107
          fullpath: '/juju-ui/models/models.js'
67
104
        },
108
        },
68
105
109
69
106
        // Connectivity
110
        // Connectivity
70
107
        'juju-env': {
111
        'juju-env': {
71
108
          requires: ['reconnecting-websocket'],
72
109
          fullpath: '/juju-ui/store/env.js'
112
          fullpath: '/juju-ui/store/env.js'
73
110
        },
113
        },
74
111
114
75
@@ -114,7 +117,6 @@
76
114
        },
117
        },
77
115
118
78
116
        'juju-charm-store': {
119
        'juju-charm-store': {
79
117
          requires: ['juju-charm-id'],
80
118
          fullpath: '/juju-ui/store/charm.js'
120
          fullpath: '/juju-ui/store/charm.js'
81
119
        },
121
        },
82
120
122
83
@@ -125,13 +127,7 @@
84
125
127
85
126
        // App
128
        // App
86
127
        'juju-gui': {
129
        'juju-gui': {
94
128
          fullpath: '/juju-ui/app.js',
130
          fullpath: '/juju-ui/app.js'
88
129
          requires: [
89
130
            'juju-controllers',
90
131
            'juju-views',
91
132
            'juju-models',
92
133
            'juju-view-charm-search'
93
134
          ]
95
135
        }
131
        }
96
136
      }
132
      }
97
137
    }
133
    }
98
138
134
99
=== modified file 'app/store/charm.js'
100
--- app/store/charm.js	2012-11-05 21:24:42 +0000
101
+++ app/store/charm.js	2012-11-20 23:07:20 +0000
102
@@ -114,6 +114,7 @@
103
114
114
104
115
}, '0.1.0', {
115
}, '0.1.0', {
105
116
  requires: [
116
  requires: [
106
117
    'juju-charm-id',
107
117
    'datasource-io',
118
    'datasource-io',
108
118
    'json-parse'
119
    'json-parse'
109
119
  ]
120
  ]
110
120
121
111
=== modified file 'test/test_app.js'
112
--- test/test_app.js	2012-11-14 14:34:31 +0000
113
+++ test/test_app.js	2012-11-20 23:07:20 +0000
114
@@ -31,196 +31,181 @@
115
31
  return app;
31
  return app;
116
32
}
32
}
117
33
33
309
34
describe('Application basics', function() {
34
YUI(GlobalConfig).use(['juju-gui', 'juju-tests-utils'], function(Y) {
310
35
  var Y, app, container;
35
  describe('Application basics', function() {
311
36
36
    var app, container;
312
37
  before(function(done) {
37
313
38
    Y = YUI(GlobalConfig).use(['juju-gui', 'juju-tests-utils'], function(Y) {
38
    beforeEach(function() {
314
39
      done();
39
      if (container) {
315
40
    });
40
        container.remove(true);
316
41
  });
41
      }
317
42
42
      container = Y.one('#main')
318
43
  beforeEach(function(done) {
43
        .appendChild(Y.Node.create('<div/>'))
319
44
    //  XXX Apparently removing a DOM node is asynchronous (on Chrome at least)
44
          .set('id', 'test-container')
320
45
    //  and we occasionally lose the race if this code is in the afterEach
45
          .addClass('container')
321
46
    //  function, so instead we do it here, but only if one has previously been
46
          .append(Y.Node.create('<span/>')
322
47
    //  created.
47
            .set('id', 'environment-name'))
323
48
    if (container) {
48
          .append(Y.Node.create('<span/>')
324
49
      container.remove(true);
49
            .set('id', 'provider-type'));
325
50
    }
50
      app = new Y.juju.App(
326
51
    container = Y.one('#main')
51
          { container: container,
327
52
      .appendChild(Y.Node.create('<div/>'))
52
            viewContainer: container});
328
53
        .set('id', 'test-container')
53
      injectData(app);
329
54
        .addClass('container')
54
    });
330
55
        .append(Y.Node.create('<span/>')
55
331
56
          .set('id', 'environment-name'))
56
    it('should produce a valid index', function() {
332
57
        .append(Y.Node.create('<span/>')
57
      var container = app.get('container');
333
58
          .set('id', 'provider-type'));
58
      app.render();
334
59
    app = new Y.juju.App(
59
      container.getAttribute('id').should.equal('test-container');
335
60
        { container: container,
60
      container.getAttribute('class').should.include('container');
336
61
          viewContainer: container});
61
    });
337
62
    injectData(app);
62
338
63
    done();
63
    it('should be able to route objects to internal URLs', function() {
339
64
  });
64
      // take handles to database objects and ensure we can route to the view
340
65
65
      // needed to show them
341
66
  it('should produce a valid index', function() {
66
      var wordpress = app.db.services.getById('wordpress'),
342
67
    var container = app.get('container');
67
          wp0 = app.db.units.get_units_for_service(wordpress)[0],
343
68
    app.render();
68
          wp_charm = app.db.charms.add({id: wordpress.get('charm')});
344
69
    container.getAttribute('id').should.equal('test-container');
69
345
70
    container.getAttribute('class').should.include('container');
70
      // 'service/wordpress/' is the primary and so other URL are not returned
346
71
  });
71
      app.getModelURL(wordpress).should.equal('/service/wordpress/');
347
72
72
      // however passing 'intent' can force selection of another
348
73
  it('should be able to route objects to internal URLs', function() {
73
      app.getModelURL(wordpress, 'config').should.equal(
349
74
    // take handles to database objects and ensure we can route to the view
74
          '/service/wordpress/config');
350
75
    // needed to show them
75
351
76
    var wordpress = app.db.services.getById('wordpress'),
76
      // service units use argument rewriting (thus not /u/wp/0)
352
77
        wp0 = app.db.units.get_units_for_service(wordpress)[0],
77
      app.getModelURL(wp0).should.equal('/unit/wordpress-0/');
353
78
        wp_charm = app.db.charms.add({id: wordpress.get('charm')});
78
354
79
79
      // charms also require a mapping but only a name, not a function
355
80
    // 'service/wordpress/' is the primary and so other URL are not returned
80
      app.getModelURL(wp_charm).should.equal(
356
81
    app.getModelURL(wordpress).should.equal('/service/wordpress/');
81
          '/charms/charms/precise/wordpress-6/json');
357
82
    // however passing 'intent' can force selection of another
82
    });
358
83
    app.getModelURL(wordpress, 'config').should.equal(
83
359
84
        '/service/wordpress/config');
84
    it('should display the configured environment name', function() {
360
85
85
      var environment_name = 'This is the environment name.  Deal with it.';
361
86
    // service units use argument rewriting (thus not /u/wp/0)
86
      app = new Y.juju.App(
362
87
    app.getModelURL(wp0).should.equal('/unit/wordpress-0/');
87
          { container: container,
363
88
88
            viewContainer: container,
364
89
    // charms also require a mapping but only a name, not a function
89
            environment_name: environment_name});
365
90
    app.getModelURL(wp_charm).should.equal(
90
      assert.equal(
366
91
        '/charms/charms/precise/wordpress-6/json');
91
          container.one('#environment-name').get('text'),
367
92
  });
92
          environment_name);
368
93
93
    });
369
94
  it('should display the configured environment name', function() {
94
370
95
    var environment_name = 'This is the environment name.  Deal with it.';
95
    it('should show a generic environment name if none configured', function() {
371
96
    app = new Y.juju.App(
96
      app = new Y.juju.App(
372
97
        { container: container,
97
          { container: container,
373
98
          viewContainer: container,
98
            viewContainer: container});
374
99
          environment_name: environment_name});
99
      assert.equal(
375
100
    assert.equal(
100
          container.one('#environment-name').get('text'),
376
101
        container.one('#environment-name').get('text'),
101
          'Environment');
377
102
        environment_name);
102
    });
378
103
  });
103
379
104
104
    it('should show the provider type, when available', function() {
380
105
  it('should show a generic environment name if none configured', function() {
105
      var providerType = 'excellent provider';
381
106
    app = new Y.juju.App(
106
      // Since no provider type has been set yet, none is displayed.
382
107
        { container: container,
107
      assert.equal(
383
108
          viewContainer: container});
108
          container.one('#provider-type').get('text'),
384
109
    assert.equal(
109
          '');
385
110
        container.one('#environment-name').get('text'),
110
      app.env.set('providerType', providerType);
386
111
        'Environment');
111
      // The provider type has been displayed.
387
112
  });
112
      assert.equal(
388
113
113
          container.one('#provider-type').get('text'),
389
114
  it('should show the provider type, when available', function() {
114
          'on ' + providerType);
390
115
    var providerType = 'excellent provider';
115
    });
391
116
    // Since no provider type has been set yet, none is displayed.
116
392
117
    assert.equal(
117
  });
393
118
        container.one('#provider-type').get('text'),
118
});
394
119
        '');
119
395
120
    app.env.set('providerType', providerType);
120
YUI(GlobalConfig).use(['juju-gui', 'juju-tests-utils'], function(Y) {
396
121
    // The provider type has been displayed.
121
  describe('Application Connection State', function() {
397
122
    assert.equal(
122
    var container;
398
123
        container.one('#provider-type').get('text'),
123
399
124
        'on ' + providerType);
124
    before(function() {
400
125
  });
125
      container = Y.Node.create('<div id="test" class="container"></div>');
401
126
126
    });
402
127
});
127
403
128
128
    it('should be able to handle env connection status changes', function() {
404
129
129
      var juju = Y.namespace('juju'),
405
130
describe('Application Connection State', function() {
130
          conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
406
131
  var Y, container;
131
          env = new juju.Environment({conn: conn}),
407
132
132
          app = new Y.juju.App({env: env, container: container}),
408
133
  before(function(done) {
133
          reset_called = false,
409
134
    Y = YUI(GlobalConfig).use(['juju-gui', 'juju-tests-utils'], function(Y) {
134
          noop = function() {return this;};
410
135
      container = Y.Node.create('<div id="test" class="container"></div>');
135
411
136
      done();
136
412
137
        });
137
      // mock the db
413
138
138
      app.db = {
414
139
  });
139
        // mock out notifications
415
140
140
        // so app can start normally
416
141
  it('should be able to handle env connection status changes', function() {
141
        notifications: {
417
142
    var juju = Y.namespace('juju'),
142
          addTarget: noop,
418
143
        conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
143
          after: noop,
419
144
        env = new juju.Environment({conn: conn}),
144
          filter: noop,
420
145
        app = new Y.juju.App({env: env, container: container}),
145
          map: noop,
421
146
        reset_called = false,
146
          on: noop,
422
147
        noop = function() {return this;};
147
          size: function() {return 0;}
423
148
148
        },
424
149
149
        reset: function() {
425
150
    // mock the db
150
          reset_called = true;
426
151
    app.db = {
151
                 }
427
152
      // mock out notifications
152
      };
428
153
      // so app can start normally
153
      env.connect();
429
154
      notifications: {
154
      conn.open();
430
155
        addTarget: noop,
155
      reset_called.should.equal(true);
431
156
        after: noop,
156
432
157
        filter: noop,
157
      // trigger a second time and verify
433
158
        map: noop,
158
      reset_called = false;
434
159
        on: noop,
159
      conn.open();
435
160
        size: function() {return 0;}
160
      reset_called.should.equal(true);
436
161
      },
161
    });
437
162
      reset: function() {
162
438
163
        reset_called = true;
163
  });
439
164
               }
164
});
440
165
    };
165
441
166
    env.connect();
166
YUI(GlobalConfig).use(['juju-models', 'juju-gui', 'datasource-local',
442
167
    conn.open();
167
  'juju-tests-utils', 'json-stringify'], function(Y) {
443
168
    reset_called.should.equal(true);
168
  describe('Application prefetching', function() {
444
169
169
    var models, conn, env, app, container, charm_store, data, juju;
445
170
    // trigger a second time and verify
170
446
171
    reset_called = false;
171
    before(function() {
447
172
    conn.open();
172
      models = Y.namespace('juju.models');
448
173
    reset_called.should.equal(true);
173
    });
449
174
  });
174
450
175
175
    beforeEach(function() {
451
176
});
176
      conn = new (Y.namespace('juju-tests.utils')).SocketStub(),
452
177
177
      env = new Y.juju.Environment({conn: conn});
453
178
describe('Application prefetching', function() {
178
      env.connect();
454
179
  var Y, models, conn, env, app, container, charm_store, data, juju;
179
      conn.open();
455
180
180
      container = Y.Node.create('<div id="test" class="container"></div>');
456
181
  before(function(done) {
181
      data = [];
457
182
    Y = YUI(GlobalConfig).use(
182
      app = new Y.juju.App(
458
183
        'juju-models', 'juju-gui', 'datasource-local', 'juju-tests-utils',
183
          { container: container,
459
184
        'json-stringify',
184
            viewContainer: container,
460
185
        function(Y) {
185
            env: env,
461
186
          models = Y.namespace('juju.models');
186
            charm_store: {} });
462
187
          done();
187
463
188
        });
188
      app.updateEndpoints = function() {};
464
189
  });
189
      env.get_endpoints = function() {};
465
190
190
    });
466
191
  beforeEach(function() {
191
467
192
    conn = new (Y.namespace('juju-tests.utils')).SocketStub(),
192
    afterEach(function() {
468
193
    env = new Y.juju.Environment({conn: conn});
193
      container.destroy();
469
194
    env.connect();
194
      app.destroy();
470
195
    conn.open();
195
    });
471
196
    container = Y.Node.create('<div id="test" class="container"></div>');
196
472
197
    data = [];
197
    it('must prefetch charm and service for service pages', function() {
473
198
    app = new Y.juju.App(
198
      injectData(app);
474
199
        { container: container,
199
      var _ = expect(
475
200
          viewContainer: container,
200
          app.db.charms.getById('cs:precise/wordpress-6')).to.not.exist;
476
201
          env: env,
201
      app.show_service({params: {id: 'wordpress'}, query: {}});
477
202
          charm_store: {} });
202
      // The app made a request of juju for the service info.
478
203
203
      conn.messages[conn.messages.length - 2].op.should.equal('get_service');
479
204
    app.updateEndpoints = function() {};
204
      // The app also requested juju (not the charm store--see discussion in
480
205
    env.get_endpoints = function() {};
205
      // app/models/charm.js) for the charm info.
481
206
  });
206
      conn.last_message().op.should.equal('get_charm');
482
207
207
      // Tests of the actual load machinery are in the model and env tests, and
483
208
  afterEach(function() {
208
      // so are not repeated here.
484
209
    container.destroy();
209
    });
294
210
    app.destroy();
295
211
  });
296
212
297
213
  it('must prefetch charm and service for service pages', function() {
298
214
    injectData(app);
299
215
    var _ = expect(
300
216
        app.db.charms.getById('cs:precise/wordpress-6')).to.not.exist;
301
217
    app.show_service({params: {id: 'wordpress'}, query: {}});
302
218
    // The app made a request of juju for the service info.
303
219
    conn.messages[conn.messages.length - 2].op.should.equal('get_service');
304
220
    // The app also requested juju (not the charm store--see discussion in
305
221
    // app/models/charm.js) for the charm info.
306
222
    conn.last_message().op.should.equal('get_charm');
307
223
    // Tests of the actual load machinery are in the model and env tests, and
308
224
    // so are not repeated here.
485
225
  });
210
  });
486
226
});
211
});
487
227
212
488
=== modified file 'test/test_app_hotkeys.js'
489
--- test/test_app_hotkeys.js	2012-11-20 15:39:46 +0000
490
+++ test/test_app_hotkeys.js	2012-11-20 23:07:20 +0000
491
@@ -1,12 +1,11 @@
492
1
'use strict';
1
'use strict';
493
2
2
496
3
describe('application hotkeys', function() {
3
YUI(GlobalConfig).use(['juju-gui', 'juju-tests-utils', 'node-event-simulate'],
497
4
  var Y, app, container, env, conn, testUtils, windowNode;
4
    function(Y) {
498
5
      describe('application hotkeys', function() {
499
6
        var app, container, env, conn, testUtils, windowNode;
500
5
7
505
6
  before(function() {
8
        before(function() {
502
7
    Y = YUI(GlobalConfig).use(
503
8
        ['juju-gui', 'juju-tests-utils',
504
9
          'node-event-simulate'], function(Y) {
506
10
          windowNode = Y.one(window);
9
          windowNode = Y.one(window);
507
11
          app = new Y.juju.App({
10
          app = new Y.juju.App({
508
12
            env: env,
11
            env: env,
509
@@ -15,49 +14,50 @@
510
15
          });
14
          });
511
16
          app.activateHotkeys();
15
          app.activateHotkeys();
512
17
        });
16
        });
559
18
  });
17
560
19
18
        afterEach(function() {
561
20
  afterEach(function() {
19
          container.remove(true);
562
21
    container.remove(true);
20
        });
563
22
  });
21
564
23
22
        beforeEach(function() {
565
24
  beforeEach(function() {
23
          container = Y.one('#main').appendChild(Y.Node.create(
566
25
    container = Y.one('#main').appendChild(Y.Node.create('<div/>')).set('id',
24
              '<div/>')).set('id', 'test-container').append(
567
26
        'test-container').append(
25
              Y.Node.create('<input />').set('id', 'charm-search-field'));
568
27
        Y.Node.create('<input />').set('id', 'charm-search-field'));
26
          testUtils = Y.namespace('juju-tests.utils');
569
28
    testUtils = Y.namespace('juju-tests.utils');
27
          env = {
570
29
    env = {
28
            get: function() {
571
30
      get: function() {
29
            },
572
31
      },
30
            on: function() {
573
32
      on: function() {
31
            },
574
33
      },
32
            after: function() {
575
34
      after: function() {
33
            }
576
35
      }
34
          };
577
36
    };
35
        });
578
37
  });
36
579
38
37
        it('should listen for alt-S events', function() {
580
39
  it('should listen for alt-S events', function() {
38
          app.render();
581
40
    app.render();
39
          windowNode.simulate('keydown', {
582
41
    windowNode.simulate('keydown', {
40
            keyCode: 83, // "S" key
583
42
      keyCode: 83, // "S" key
41
            altKey: true
584
43
      altKey: true
42
          });
585
44
    });
43
          // Did charm-search-field get the focus?
586
45
    // Did charm-search-field get the focus?
44
          assert.equal(Y.one('#charm-search-field'),
587
46
    assert.equal(Y.one('#charm-search-field'), Y.one(document.activeElement));
45
              Y.one(document.activeElement));
588
47
  });
46
        });
589
48
47
590
49
  it('should listen for alt-E events', function() {
48
        it('should listen for alt-E events', function() {
591
50
    var altEtriggered = false;
49
          var altEtriggered = false;
592
51
    app.on('navigateTo', function(param) {
50
          app.on('navigateTo', function(param) {
593
52
      if (param && param.url === '/') {
51
            if (param && param.url === '/') {
594
53
        altEtriggered = true;
52
              altEtriggered = true;
595
54
      }
53
            }
596
55
    });
54
          });
597
56
    app.render();
55
          app.render();
598
57
    windowNode.simulate('keydown', {
56
          windowNode.simulate('keydown', {
599
58
      keyCode: 69, // "E" key
57
            keyCode: 69, // "E" key
600
59
      altKey: true
58
            altKey: true
601
60
    });
59
          });
602
61
    assert.isTrue(altEtriggered);
60
          assert.isTrue(altEtriggered);
603
62
  });
61
        });
604
63
});
62
      });
605
63
    });
606
64
64
607
=== modified file 'test/test_model.js'
608
--- test/test_model.js	2012-10-23 20:02:17 +0000
609
+++ test/test_model.js	2012-11-20 23:07:20 +0000
610
@@ -1,15 +1,11 @@
611
1
'use strict';
1
'use strict';
612
2
2
615
3
(function() {
3
YUI(GlobalConfig).use('juju-models', function(Y) {
614
4
616
5
  describe('charm normalization', function() {
4
  describe('charm normalization', function() {
618
6
    var Y, models;
5
    var models;
619
7
6
625
8
    before(function(done) {
7
    before(function() {
626
9
      Y = YUI(GlobalConfig).use('juju-models', function(Y) {
8
      models = Y.namespace('juju.models');
622
10
            models = Y.namespace('juju.models');
623
11
            done();
624
12
      });
627
13
    });
9
    });
628
14
10
629
15
    it('must create derived attributes from official charm id', function() {
11
    it('must create derived attributes from official charm id', function() {
630
@@ -31,15 +27,14 @@
631
31
    });
27
    });
632
32
28
633
33
  });
29
  });
634
30
});
635
34
31
636
32
YUI(GlobalConfig).use('juju-models', function(Y) {
637
35
  describe('juju models', function() {
33
  describe('juju models', function() {
639
36
    var Y, models;
34
    var models;
640
37
35
646
38
    before(function(done) {
36
    before(function() {
647
39
      Y = YUI(GlobalConfig).use('juju-models', function(Y) {
37
      models = Y.namespace('juju.models');
643
40
            models = Y.namespace('juju.models');
644
41
            done();
645
42
      });
648
43
    });
38
    });
649
44
39
650
45
    it('must be able to create charm', function() {
40
    it('must be able to create charm', function() {
651
@@ -355,19 +350,17 @@
652
355
                .should.eql(['relation-2', 'relation-3', 'relation-4']);
350
                .should.eql(['relation-2', 'relation-3', 'relation-4']);
653
356
        });
351
        });
654
357
  });
352
  });
655
353
});
656
358
354
657
355
YUI(GlobalConfig).use(['juju-models', 'juju-gui', 'datasource-local',
658
356
  'juju-tests-utils', 'json-stringify',
659
357
  'juju-charm-store'], function(Y) {
660
359
  describe('juju charm load', function() {
358
  describe('juju charm load', function() {
662
360
    var Y, models, conn, env, app, container, charm_store, data, juju;
359
    var models, conn, env, app, container, charm_store, data, juju;
663
361
360
673
362
    before(function(done) {
361
    before(function() {
674
363
      Y = YUI(GlobalConfig).use(
362
      models = Y.namespace('juju.models');
675
364
          'juju-models', 'juju-gui', 'datasource-local', 'juju-tests-utils',
363
      juju = Y.namespace('juju');
667
365
          'json-stringify', 'juju-charm-store',
668
366
          function(Y) {
669
367
            models = Y.namespace('juju.models');
670
368
            juju = Y.namespace('juju');
671
369
            done();
672
370
          });
676
371
    });
364
    });
677
372
365
678
373
    beforeEach(function() {
366
    beforeEach(function() {
679
@@ -513,4 +506,4 @@
680
513
    });
506
    });
681
514
507
682
515
  });
508
  });
684
516
})();
509
});
685
517
510
686
=== modified file 'test/test_notifications.js'
687
--- test/test_notifications.js	2012-11-16 13:38:21 +0000
688
+++ test/test_notifications.js	2012-11-20 23:07:20 +0000
689
@@ -1,477 +1,462 @@
690
1
'use strict';
1
'use strict';
691
2
2
759
3
describe('notifications', function() {
3
YUI(GlobalConfig).use(['juju-gui', 'node-event-simulate', 'juju-tests-utils'],
693
4
  var Y, juju, models, views;
694
5
695
6
  var default_env = {
696
7
    'result': [
697
8
      ['service', 'add', {
698
9
        'charm': 'cs:precise/wordpress-6',
699
10
        'id': 'wordpress',
700
11
        'exposed': false
701
12
      }],
702
13
      ['service', 'add', {
703
14
        'charm': 'cs:precise/mediawiki-3',
704
15
        'id': 'mediawiki',
705
16
        'exposed': false
706
17
      }],
707
18
      ['service', 'add', {
708
19
        'charm': 'cs:precise/mysql-6',
709
20
        'id': 'mysql'
710
21
      }],
711
22
      ['relation', 'add', {
712
23
        'interface': 'reversenginx',
713
24
        'scope': 'global',
714
25
        'endpoints':
715
26
         [['wordpress', {'role': 'peer', 'name': 'loadbalancer'}]],
716
27
        'id': 'relation-0000000000'
717
28
      }],
718
29
      ['relation', 'add', {
719
30
        'interface': 'mysql',
720
31
        'scope': 'global',
721
32
        'endpoints':
722
33
         [['mysql', {'role': 'server', 'name': 'db'}],
723
34
          ['wordpress', {'role': 'client', 'name': 'db'}]],
724
35
        'id': 'relation-0000000001'
725
36
      }],
726
37
      ['machine', 'add', {
727
38
        'agent-state': 'running',
728
39
        'instance-state': 'running',
729
40
        'id': 0,
730
41
        'instance-id': 'local',
731
42
        'dns-name': 'localhost'
732
43
      }],
733
44
      ['unit', 'add', {
734
45
        'machine': 0,
735
46
        'agent-state': 'started',
736
47
        'public-address': '192.168.122.113',
737
48
        'id': 'wordpress/0'
738
49
      }],
739
50
      ['unit', 'add', {
740
51
        'machine': 0,
741
52
        'agent-state': 'error',
742
53
        'public-address': '192.168.122.222',
743
54
        'id': 'mysql/0'
744
55
      }]
745
56
    ],
746
57
    'op': 'delta'
747
58
  };
748
59
749
60
750
61
  before(function(done) {
751
62
    Y = YUI(GlobalConfig).use([
752
63
      'juju-models',
753
64
      'juju-views',
754
65
      'juju-gui',
755
66
      'juju-env',
756
67
      'node-event-simulate',
757
68
      'juju-tests-utils'],
758
69
760
70
    function(Y) {
4
    function(Y) {
1114
71
      juju = Y.namespace('juju');
5
      describe('notifications', function() {
1115
72
      models = Y.namespace('juju.models');
6
        var juju, models, views;
1116
73
      views = Y.namespace('juju.views');
7
1117
74
      done();
8
        var default_env = {
1118
75
    });
9
          'result': [
1119
76
  });
10
            ['service', 'add', {
1120
77
11
              'charm': 'cs:precise/wordpress-6',
1121
78
  it('must be able to make notification and lists of notifications',
12
              'id': 'wordpress',
1122
79
     function() {
13
              'exposed': false
1123
80
        var note1 = new models.Notification({
14
            }],
1124
81
         title: 'test1',
15
            ['service', 'add', {
1125
82
         message: 'Hello'
16
              'charm': 'cs:precise/mediawiki-3',
1126
83
        }),
17
              'id': 'mediawiki',
1127
84
            note2 = new models.Notification({
18
              'exposed': false
1128
85
         title: 'test2',
19
            }],
1129
86
         message: 'I said goodnight!'
20
            ['service', 'add', {
1130
87
            }),
21
              'charm': 'cs:precise/mysql-6',
1131
88
            notifications = new models.NotificationList();
22
              'id': 'mysql'
1132
89
23
            }],
1133
90
        notifications.add([note1, note2]);
24
            ['relation', 'add', {
1134
91
        notifications.size().should.equal(2);
25
              'interface': 'reversenginx',
1135
92
26
              'scope': 'global',
1136
93
        // timestamp should be generated once
27
              'endpoints':
1137
94
        var ts = note1.get('timestamp');
28
               [['wordpress', {'role': 'peer', 'name': 'loadbalancer'}]],
1138
95
        note1.get('timestamp').should.equal(ts);
29
              'id': 'relation-0000000000'
1139
96
        // force an update so we can test ordering
30
            }],
1140
97
        // fast execution can result in same timestamp
31
            ['relation', 'add', {
1141
98
        note2.set('timestamp', ts + 1);
32
              'interface': 'mysql',
1142
99
        note2.get('timestamp').should.be.above(ts);
33
              'scope': 'global',
1143
100
34
              'endpoints':
1144
101
        // defaults as expected
35
               [['mysql', {'role': 'server', 'name': 'db'}],
1145
102
        note1.get('level').should.equal('info');
36
                ['wordpress', {'role': 'client', 'name': 'db'}]],
1146
103
        note2.get('level').should.equal('info');
37
              'id': 'relation-0000000001'
1147
104
        // the sort order on the list should be by
38
            }],
1148
105
        // timestamp
39
            ['machine', 'add', {
1149
106
        notifications.get('title').should.eql(['test2', 'test1']);
40
              'agent-state': 'running',
1150
107
     });
41
              'instance-state': 'running',
1151
108
42
              'id': 0,
1152
109
  it('must be able to render its view with sample data',
43
              'instance-id': 'local',
1153
110
     function() {
44
              'dns-name': 'localhost'
1154
111
       var note1 = new models.Notification({
45
            }],
1155
112
         title: 'test1', message: 'Hello'}),
46
            ['unit', 'add', {
1156
113
           note2 = new models.Notification({
47
              'machine': 0,
1157
114
         title: 'test2', message: 'I said goodnight!'}),
48
              'agent-state': 'started',
1158
115
           notifications = new models.NotificationList(),
49
              'public-address': '192.168.122.113',
1159
116
           container = Y.Node.create('<div id="test">'),
50
              'id': 'wordpress/0'
1160
117
           env = new juju.Environment(),
51
            }],
1161
118
           view = new views.NotificationsView({
52
            ['unit', 'add', {
1162
119
                   container: container,
53
              'machine': 0,
1163
120
                   notifications: notifications,
54
              'agent-state': 'error',
1164
121
                   env: env});
55
              'public-address': '192.168.122.222',
1165
122
       view.render();
56
              'id': 'mysql/0'
1166
123
       // Verify the expected elements appear in the view
57
            }]
1167
124
       container.one('#notify-list').should.not.equal(undefined);
58
          ],
1168
125
       container.destroy();
59
          'op': 'delta'
1169
126
     });
60
        };
1170
127
61
1171
128
  it('must be able to limit the size of notification events',
62
1172
129
     function() {
63
        before(function() {
1173
130
       var note1 = new models.Notification({
64
          juju = Y.namespace('juju');
1174
131
         title: 'test1',
65
          models = Y.namespace('juju.models');
1175
132
         message: 'Hello'
66
          views = Y.namespace('juju.views');
1176
133
       }),
67
        });
1177
134
           note2 = new models.Notification({
68
1178
135
         title: 'test2',
69
        it('must be able to make notification and lists of notifications',
1179
136
         message: 'I said goodnight!'
70
           function() {
1180
137
       }),
71
             var note1 = new models.Notification({
1181
138
           note3 = new models.Notification({
72
               title: 'test1',
1182
139
         title: 'test3',
73
               message: 'Hello'
1183
140
         message: 'Never remember'
74
             }),
1184
141
       }),
75
             note2 = new models.Notification({
1185
142
           notifications = new models.NotificationList({
76
               title: 'test2',
1186
143
         max_size: 2
77
               message: 'I said goodnight!'
1187
144
       });
78
             }),
1188
145
79
             notifications = new models.NotificationList();
1189
146
       notifications.add([note1, note2]);
80
1190
147
       notifications.size().should.equal(2);
81
             notifications.add([note1, note2]);
1191
148
82
             notifications.size().should.equal(2);
1192
149
       // Adding a new notification should pop the oldest from the list (we
83
1193
150
       // exceed max_size)
84
             // timestamp should be generated once
1194
151
       notifications.add(note3);
85
             var ts = note1.get('timestamp');
1195
152
       notifications.size().should.equal(2);
86
             note1.get('timestamp').should.equal(ts);
1196
153
       notifications.get('title').should.eql(['test3', 'test2']);
87
             // force an update so we can test ordering
1197
154
     });
88
             // fast execution can result in same timestamp
1198
155
89
             note2.set('timestamp', ts + 1);
1199
156
  it('must be able to get notifications for a given model',
90
             note2.get('timestamp').should.be.above(ts);
1200
157
     function() {
91
1201
158
       var m = new models.Service({id: 'mediawiki'}),
92
             // defaults as expected
1202
159
           note1 = new models.Notification({
93
             note1.get('level').should.equal('info');
1203
160
         title: 'test1',
94
             note2.get('level').should.equal('info');
1204
161
         message: 'Hello',
95
             // the sort order on the list should be by
1205
162
         modelId: m
96
             // timestamp
1206
163
       }),
97
             notifications.get('title').should.eql(['test2', 'test1']);
1207
164
           note2 = new models.Notification({
98
           });
1208
165
         title: 'test2',
99
1209
166
         message: 'I said goodnight!'
100
        it('must be able to render its view with sample data',
1210
167
       }),
101
           function() {
1211
168
           notifications = new models.NotificationList();
102
             var note1 = new models.Notification({
1212
169
103
               title: 'test1', message: 'Hello'}),
1213
170
       notifications.add([note1, note2]);
104
             note2 = new models.Notification({
1214
171
       notifications.size().should.equal(2);
105
               title: 'test2', message: 'I said goodnight!'}),
1215
172
       notifications.getNotificationsForModel(m).should.eql(
106
             notifications = new models.NotificationList(),
1216
173
       [note1]);
107
             container = Y.Node.create('<div id="test">'),
1217
174
108
             env = new juju.Environment(),
1218
175
     });
109
             view = new views.NotificationsView({
1219
176
110
                     container: container,
1220
177
  it('must be able to include and show object links', function() {
111
                     notifications: notifications,
1221
178
    var container = Y.Node.create('<div id="test">'),
112
                     env: env});
1222
179
        conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
113
             view.render();
1223
180
        env = new juju.Environment({conn: conn}),
114
             // Verify the expected elements appear in the view
1224
181
        app = new Y.juju.App({env: env, container: container}),
115
             container.one('#notify-list').should.not.equal(undefined);
1225
182
        db = app.db,
116
             container.destroy();
1226
183
        mw = db.services.create({id: 'mediawiki',
117
           });
1227
184
                                    name: 'mediawiki'}),
118
1228
185
        notifications = db.notifications,
119
        it('must be able to limit the size of notification events',
1229
186
        view = new views.NotificationsOverview({
120
           function() {
1230
187
                      container: container,
121
             var note1 = new models.Notification({
1231
188
                      notifications: notifications,
122
               title: 'test1',
1232
189
                      app: app,
123
               message: 'Hello'
1233
190
                      env: env}).render();
124
             }),
1234
191
    // we use overview here for testing as it defaults
125
             note2 = new models.Notification({
1235
192
    // to showing all notices
126
               title: 'test2',
1236
193
127
               message: 'I said goodnight!'
1237
194
    // we can use app's routing table to derive a link
128
             }),
1238
195
    notifications.create({title: 'Service Down',
129
             note3 = new models.Notification({
1239
196
      message: 'Your service has an error',
130
               title: 'test3',
1240
197
      link: app.getModelURL(mw)
131
               message: 'Never remember'
1241
198
    });
132
             }),
1242
199
    view.render();
133
             notifications = new models.NotificationList({
1243
200
    var link = container.one('.notice').one('a');
134
               max_size: 2
1244
201
    link.getAttribute('href').should.equal(
135
             });
1245
202
        '/service/mediawiki/');
136
1246
203
    link.getHTML().should.contain('View Details');
137
             notifications.add([note1, note2]);
1247
204
138
             notifications.size().should.equal(2);
1248
205
139
1249
206
    // create a new notice passing the link_title
140
             // Adding a new notification should pop the oldest from the list
1250
207
    notifications.create({title: 'Service Down',
141
             // (we exceed max_size)
1251
208
      message: 'Your service has an error',
142
             notifications.add(note3);
1252
209
      link: app.getModelURL(mw),
143
             notifications.size().should.equal(2);
1253
210
      link_title: 'Resolve this'
144
             notifications.get('title').should.eql(['test3', 'test2']);
1254
211
    });
145
           });
1255
212
    view.render();
146
1256
213
    link = container.one('.notice').one('a');
147
        it('must be able to get notifications for a given model',
1257
214
    link.getAttribute('href').should.equal(
148
           function() {
1258
215
        '/service/mediawiki/');
149
             var m = new models.Service({id: 'mediawiki'}),
1259
216
    link.getHTML().should.contain('Resolve this');
150
             note1 = new models.Notification({
1260
217
  });
151
               title: 'test1',
1261
218
152
               message: 'Hello',
1262
219
  it('must be able to evict irrelevant notices', function() {
153
               modelId: m
1263
220
    var container = Y.Node.create(
154
             }),
1264
221
        '<div id="test" class="container"></div>'),
155
             note2 = new models.Notification({
1265
222
        conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
156
               title: 'test2',
1266
223
        env = new juju.Environment({conn: conn}),
157
               message: 'I said goodnight!'
1267
224
        app = new Y.juju.App({
158
             }),
1268
225
          env: env,
159
             notifications = new models.NotificationList();
1269
226
          container: container,
160
1270
227
          viewContainer: container
161
             notifications.add([note1, note2]);
1271
228
        });
162
             notifications.size().should.equal(2);
1272
229
    var environment_delta = default_env;
163
             notifications.getNotificationsForModel(m).should.eql(
1273
230
164
             [note1]);
1274
231
    var notifications = app.db.notifications,
165
1275
232
        view = new views.NotificationsView({
166
           });
1276
233
          container: container,
167
1277
234
          notifications: notifications,
168
        it('must be able to include and show object links', function() {
1278
235
          env: app.env}).render();
169
          var container = Y.Node.create('<div id="test">'),
1279
236
170
              conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
1280
237
171
              env = new juju.Environment({conn: conn}),
1281
238
    app.env.dispatch_result(environment_delta);
172
              app = new Y.juju.App({env: env, container: container}),
1282
239
173
              db = app.db,
1283
240
174
              mw = db.services.create({id: 'mediawiki',
1284
241
    notifications.size().should.equal(7);
175
                                      name: 'mediawiki'}),
1285
242
    // we have one unit in error
176
              notifications = db.notifications,
1286
243
    view.getShowable().length.should.equal(1);
177
              view = new views.NotificationsOverview({
1287
244
178
                        container: container,
1288
245
    // now fire another delta event marking that node as
179
                        notifications: notifications,
1289
246
    // started
180
                        app: app,
1290
247
    app.env.dispatch_result({result: [['unit', 'change', {
181
                        env: env}).render();
1291
248
      'machine': 0,
182
          // we use overview here for testing as it defaults
1292
249
      'agent-state': 'started',
183
          // to showing all notices
1293
250
      'public-address': '192.168.122.222',
184
1294
251
      'id': 'mysql/0'
185
          // we can use app's routing table to derive a link
1295
252
    }]], op: 'delta'});
186
          notifications.create({title: 'Service Down',
1296
253
    notifications.size().should.equal(8);
187
            message: 'Your service has an error',
1297
254
    // This should have evicted the prior notice from seen
188
            link: app.getModelURL(mw)
1298
255
    view.getShowable().length.should.equal(0);
189
          });
1299
256
  });
190
          view.render();
1300
257
191
          var link = container.one('.notice').one('a');
1301
258
  it('must properly construct title and message based on level from ' +
192
          link.getAttribute('href').should.equal(
1302
259
     'event data',
193
              '/service/mediawiki/');
1303
260
     function() {
194
          link.getHTML().should.contain('View Details');
1304
261
       var container = Y.Node.create(
195
1305
262
       '<div id="test" class="container"></div>'),
196
1306
263
       app = new Y.juju.App({
197
          // create a new notice passing the link_title
1307
264
         container: container,
198
          notifications.create({title: 'Service Down',
1308
265
         viewContainer: container
199
            message: 'Your service has an error',
1309
266
       });
200
            link: app.getModelURL(mw),
1310
267
       var environment_delta = {
201
            link_title: 'Resolve this'
1311
268
         'result': [
202
          });
1312
269
           ['service', 'add', {
203
          view.render();
1313
270
             'charm': 'cs:precise/wordpress-6',
204
          link = container.one('.notice').one('a');
1314
271
             'id': 'wordpress'
205
          link.getAttribute('href').should.equal(
1315
272
           }],
206
              '/service/mediawiki/');
1316
273
           ['service', 'add', {
207
          link.getHTML().should.contain('Resolve this');
1317
274
             'charm': 'cs:precise/mediawiki-3',
208
        });
1318
275
             'id': 'mediawiki'
209
1319
276
           }],
210
        it('must be able to evict irrelevant notices', function() {
1320
277
           ['service', 'add', {
211
          var container = Y.Node.create(
1321
278
             'charm': 'cs:precise/mysql-6',
212
              '<div id="test" class="container"></div>'),
1322
279
             'id': 'mysql'
213
              conn = new(Y.namespace('juju-tests.utils')).SocketStub(),
1323
280
           }],
214
              env = new juju.Environment({conn: conn}),
1324
281
           ['unit', 'add', {
215
              app = new Y.juju.App({
1325
282
             'agent-state': 'install-error',
216
                env: env,
1326
283
             'id': 'wordpress/0'
217
                container: container,
1327
284
           }],
218
                viewContainer: container
1328
285
           ['unit', 'add', {
219
              });
1329
286
             'agent-state': 'error',
220
          var environment_delta = default_env;
1330
287
             'public-address': '192.168.122.222',
221
1331
288
             'id': 'mysql/0'
222
          var notifications = app.db.notifications,
1332
289
           }],
223
              view = new views.NotificationsView({
1333
290
           ['unit', 'add', {
224
                container: container,
1334
291
             'public-address': '192.168.122.222',
225
                notifications: notifications,
1335
292
             'id': 'mysql/2'
226
                env: app.env}).render();
1336
293
           }]
227
1337
294
         ],
228
1338
295
         'op': 'delta'
229
          app.env.dispatch_result(environment_delta);
1339
296
       };
230
1340
297
231
1341
298
       var notifications = app.db.notifications,
232
          notifications.size().should.equal(7);
1342
299
       view = new views.NotificationsView({
233
          // we have one unit in error
1343
300
         container: container,
234
          view.getShowable().length.should.equal(1);
1344
301
         notifications: notifications,
235
1345
302
         app: app,
236
          // now fire another delta event marking that node as
1346
303
         env: app.env}).render();
237
          // started
1347
304
238
          app.env.dispatch_result({result: [['unit', 'change', {
1348
305
       app.env.dispatch_result(environment_delta);
239
            'machine': 0,
1349
306
240
            'agent-state': 'started',
1350
307
       notifications.size().should.equal(6);
241
            'public-address': '192.168.122.222',
1351
308
       // we have one unit in error
242
            'id': 'mysql/0'
1352
309
       var showable = view.getShowable();
243
          }]], op: 'delta'});
1353
310
       showable.length.should.equal(2);
244
          notifications.size().should.equal(8);
1354
311
       // The first showable notification should indicate an error.
245
          // This should have evicted the prior notice from seen
1355
312
       showable[0].level.should.equal('error');
246
          view.getShowable().length.should.equal(0);
1356
313
       showable[0].title.should.equal('Error with mysql/0');
247
        });
1357
314
       showable[0].message.should.equal('Agent-state = error.');
248
1358
315
       // The second showable notification should also indicate an error.
249
        it('must properly construct title and message based on level from ' +
1359
316
       showable[1].level.should.equal('error');
250
           'event data',
1360
317
       showable[1].title.should.equal('Error with wordpress/0');
251
           function() {
1361
318
       showable[1].message.should.equal('Agent-state = install-error.');
252
             var container = Y.Node.create(
1362
319
       // The first non-error notice should have an 'info' level and less
253
             '<div id="test" class="container"></div>'),
1363
320
       // severe messaging.
254
             app = new Y.juju.App({
1364
321
       var notice = notifications.item(0);
255
               container: container,
1365
322
       notice.get('level').should.equal('info');
256
               viewContainer: container
1366
323
       notice.get('title').should.equal('Problem with mysql/2');
257
             });
1367
324
       notice.get('message').should.equal('');
258
             var environment_delta = {
1368
325
     });
259
               'result': [
1369
326
260
                 ['service', 'add', {
1370
327
261
                   'charm': 'cs:precise/wordpress-6',
1371
328
  it('should open on click and close on clickoutside', function(done) {
262
                   'id': 'wordpress'
1372
329
    var container = Y.Node.create(
263
                 }],
1373
330
        '<div id="test-container" style="display: none" class="container"/>'),
264
                 ['service', 'add', {
1374
331
        notifications = new models.NotificationList(),
265
                   'charm': 'cs:precise/mediawiki-3',
1375
332
        env = new juju.Environment(),
266
                   'id': 'mediawiki'
1376
333
        view = new views.NotificationsView({
267
                 }],
1377
334
          container: container,
268
                 ['service', 'add', {
1378
335
          notifications: notifications,
269
                   'charm': 'cs:precise/mysql-6',
1379
336
          env: env}).render(),
270
                   'id': 'mysql'
1380
337
        indicator;
271
                 }],
1381
338
272
                 ['unit', 'add', {
1382
339
    Y.one('body').append(container);
273
                   'agent-state': 'install-error',
1383
340
    notifications.add({title: 'testing', 'level': 'error'});
274
                   'id': 'wordpress/0'
1384
341
    indicator = container.one('#notify-indicator');
275
                 }],
1385
342
276
                 ['unit', 'add', {
1386
343
    indicator.simulate('click');
277
                   'agent-state': 'error',
1387
344
    indicator.ancestor().hasClass('open').should.equal(true);
278
                   'public-address': '192.168.122.222',
1388
345
279
                   'id': 'mysql/0'
1389
346
    Y.one('body').simulate('click');
280
                 }],
1390
347
    indicator.ancestor().hasClass('open').should.equal(false);
281
                 ['unit', 'add', {
1391
348
282
                   'public-address': '192.168.122.222',
1392
349
    container.remove();
283
                   'id': 'mysql/2'
1393
350
    done();
284
                 }]
1394
351
  });
285
               ],
1395
352
286
               'op': 'delta'
1396
353
});
287
             };
1397
354
288
1398
355
289
             var notifications = app.db.notifications,
1399
356
describe('changing notifications to words', function() {
290
             view = new views.NotificationsView({
1400
357
  var Y, juju;
291
               container: container,
1401
358
292
               notifications: notifications,
1402
359
  before(function(done) {
293
               app: app,
1403
360
    Y = YUI(GlobalConfig).use(
294
               env: app.env}).render();
1404
361
        ['juju-notification-controller'],
295
1405
362
        function(Y) {
296
             app.env.dispatch_result(environment_delta);
1406
363
          juju = Y.namespace('juju');
297
1407
364
          done();
298
             notifications.size().should.equal(6);
1408
365
        });
299
             // we have one unit in error
1409
366
  });
300
             var showable = view.getShowable();
1410
367
301
             showable.length.should.equal(2);
1411
368
  it('should correctly translate notification operations into English',
302
             // The first showable notification should indicate an error.
1412
369
     function() {
303
             showable[0].level.should.equal('error');
1413
370
       assert.equal(juju._changeNotificationOpToWords('add'), 'created');
304
             showable[0].title.should.equal('Error with mysql/0');
1414
371
       assert.equal(juju._changeNotificationOpToWords('remove'), 'removed');
305
             showable[0].message.should.equal('Agent-state = error.');
1415
372
       assert.equal(juju._changeNotificationOpToWords('not-an-op'), 'changed');
306
             // The second showable notification should also indicate an error.
1416
373
     });
307
             showable[1].level.should.equal('error');
1417
374
});
308
             showable[1].title.should.equal('Error with wordpress/0');
1418
375
309
             showable[1].message.should.equal('Agent-state = install-error.');
1419
376
describe('relation notifications', function() {
310
             // The first non-error notice should have an 'info' level and less
1420
377
  var Y, juju;
311
             // severe messaging.
1421
378
312
             var notice = notifications.item(0);
1422
379
  before(function(done) {
313
             notice.get('level').should.equal('info');
1423
380
    Y = YUI(GlobalConfig).use(
314
             notice.get('title').should.equal('Problem with mysql/2');
1424
381
        ['juju-notification-controller'],
315
             notice.get('message').should.equal('');
1425
382
        function(Y) {
316
           });
1426
383
          juju = Y.namespace('juju');
317
1427
384
          done();
318
1428
385
        });
319
        it('should open on click and close on clickoutside', function(done) {
1429
386
  });
320
          var container = Y.Node.create('<div id="test-container" ' +
1430
387
321
              'style="display: none" class="container"/>'),
1431
388
  it('should produce reasonable titles', function() {
322
              notifications = new models.NotificationList(),
1432
389
    assert.equal(
323
              env = new juju.Environment(),
1433
390
        juju._relationNotifications.title(undefined, 'add'),
324
              view = new views.NotificationsView({
1434
391
        'Relation created');
325
                container: container,
1435
392
    assert.equal(
326
                notifications: notifications,
1436
393
        juju._relationNotifications.title(undefined, 'remove'),
327
                env: env}).render(),
1437
394
        'Relation removed');
328
              indicator;
1438
395
  });
329
1439
396
330
          Y.one('body').append(container);
1440
397
  it('should generate messages about two-party relations', function() {
331
          notifications.add({title: 'testing', 'level': 'error'});
1441
398
    var changeData =
332
          indicator = container.one('#notify-indicator');
1442
399
        { endpoints:
333
1443
400
              [['endpoint0', {name: 'relation0'}],
334
          indicator.simulate('click');
1444
401
                ['endpoint1', {name: 'relation1'}]]};
335
          indicator.ancestor().hasClass('open').should.equal(true);
1445
402
    assert.equal(
336
1446
403
        juju._relationNotifications.message(undefined, 'add', changeData),
337
          Y.one('body').simulate('click');
1447
404
        'Relation between endpoint0 (relation type "relation0") and ' +
338
          indicator.ancestor().hasClass('open').should.equal(false);
1448
405
        'endpoint1 (relation type "relation1") was created');
339
1449
406
  });
340
          container.remove();
1450
407
341
          done();
1451
408
  it('should generate messages about one-party relations', function() {
342
        });
1452
409
    var changeData =
343
      });
1453
410
        { endpoints:
344
1454
411
              [['endpoint1', {name: 'relation1'}]]};
345
      describe('changing notifications to words', function() {
1455
412
    assert.equal(
346
        var juju;
1456
413
        juju._relationNotifications.message(undefined, 'add', changeData),
347
1457
414
        'Relation with endpoint1 (relation type "relation1") was created');
348
        before(function() {
1458
415
  });
349
          juju = Y.namespace('juju');
1459
416
});
350
        });
1460
417
351
1461
418
describe('notification visual feedback', function() {
352
        it('should correctly translate notification operations into English',
1462
419
  var env, models, notifications, notificationsView, notifierBox, views, Y;
353
           function() {
1463
420
354
             assert.equal(juju._changeNotificationOpToWords('add'), 'created');
1464
421
  before(function(done) {
355
             assert.equal(juju._changeNotificationOpToWords('remove'),
1465
422
    Y = YUI(GlobalConfig).use('juju-env', 'juju-models', 'juju-views',
356
                 'removed');
1466
423
        function(Y) {
357
             assert.equal(juju._changeNotificationOpToWords('not-an-op'),
1467
358
                 'changed');
1468
359
           });
1469
360
      });
1470
361
1471
362
      describe('relation notifications', function() {
1472
363
        var juju;
1473
364
1474
365
        before(function() {
1475
366
          juju = Y.namespace('juju');
1476
367
        });
1477
368
1478
369
        it('should produce reasonable titles', function() {
1479
370
          assert.equal(
1480
371
              juju._relationNotifications.title(undefined, 'add'),
1481
372
              'Relation created');
1482
373
          assert.equal(
1483
374
              juju._relationNotifications.title(undefined, 'remove'),
1484
375
              'Relation removed');
1485
376
        });
1486
377
1487
378
        it('should generate messages about two-party relations', function() {
1488
379
          var changeData =
1489
380
              { endpoints:
1490
381
                    [['endpoint0', {name: 'relation0'}],
1491
382
                     ['endpoint1', {name: 'relation1'}]]};
1492
383
          assert.equal(
1493
384
              juju._relationNotifications.message(undefined, 'add',
1494
385
                  changeData), 'Relation between endpoint0 (relation type ' +
1495
386
                  '"relation0") and endpoint1 (relation type "relation1") ' +
1496
387
                  'was created');
1497
388
        });
1498
389
1499
390
        it('should generate messages about one-party relations', function() {
1500
391
          var changeData =
1501
392
              { endpoints:
1502
393
                    [['endpoint1', {name: 'relation1'}]]};
1503
394
          assert.equal(
1504
395
              juju._relationNotifications.message(undefined, 'add',
1505
396
                  changeData), 'Relation with endpoint1 (relation type' +
1506
397
                  '"relation1") was created');
1507
398
        });
1508
399
      });
1509
400
1510
401
      describe('notification visual feedback', function() {
1511
402
        var env, models, notifications, notificationsView, notifierBox, views;
1512
403
1513
404
        before(function() {
1514
424
          var juju = Y.namespace('juju');
405
          var juju = Y.namespace('juju');
1515
425
          env = new juju.Environment();
406
          env = new juju.Environment();
1516
426
          models = Y.namespace('juju.models');
407
          models = Y.namespace('juju.models');
1517
427
          views = Y.namespace('juju.views');
408
          views = Y.namespace('juju.views');
1529
428
          done();
409
        });
1530
429
        });
410
1531
430
  });
411
        // Instantiate the notifications model list and view.
1532
431
412
        // Also create the notifier box and attach it as first element of the
1533
432
  // Instantiate the notifications model list and view.
413
        // body.
1534
433
  // Also create the notifier box and attach it as first element of the body.
414
        beforeEach(function() {
1535
434
  beforeEach(function() {
415
          notifications = new models.NotificationList();
1536
435
    notifications = new models.NotificationList();
416
          notificationsView = new views.NotificationsView({
1537
436
    notificationsView = new views.NotificationsView({
417
            env: env,
1538
437
      env: env,
418
            notifications: notifications
1539
438
      notifications: notifications
419
          });
1540
420
          notifierBox = Y.Node.create('<div id="notifier-box"></div>');
1541
421
          notifierBox.setStyle('display', 'none');
1542
422
          Y.one('body').prepend(notifierBox);
1543
423
        });
1544
424
1545
425
        // Destroy the notifier box created in beforeEach.
1546
426
        afterEach(function() {
1547
427
          notifierBox.remove();
1548
428
          notifierBox.destroy(true);
1549
429
        });
1550
430
1551
431
        // Assert the notifier box contains the expectedNumber of notifiers.
1552
432
        var assertNumNotifiers = function(expectedNumber) {
1553
433
          assert.equal(expectedNumber, notifierBox.get('children').size());
1554
434
        };
1555
435
1556
436
        it('should appear when a new error is notified', function() {
1557
437
          notifications.add({title: 'mytitle', level: 'error'});
1558
438
          assertNumNotifiers(1);
1559
439
        });
1560
440
1561
441
        it('should only appear when the DOM contains the notifier box',
1562
442
            function() {
1563
443
             notifierBox.remove();
1564
444
             notifications.add({title: 'mytitle', level: 'error'});
1565
445
             assertNumNotifiers(0);
1566
446
           });
1567
447
1568
448
        it('should not appear when the notification is not an error',
1569
449
            function() {
1570
450
             notifications.add({title: 'mytitle', level: 'info'});
1571
451
             assertNumNotifiers(0);
1572
452
           });
1573
453
1574
454
        it('should not appear when the notification comes form delta',
1575
455
            function() {
1576
456
             notifications.add({title: 'mytitle', level: 'error', isDelta:
1577
457
               true});
1578
458
             assertNumNotifiers(0);
1579
459
           });
1580
460
1581
461
      });
1582
439
    });
462
    });
1583
440
    notifierBox = Y.Node.create('<div id="notifier-box"></div>');
1584
441
    notifierBox.setStyle('display', 'none');
1585
442
    Y.one('body').prepend(notifierBox);
1586
443
  });
1587
444
1588
445
  // Destroy the notifier box created in beforeEach.
1589
446
  afterEach(function() {
1590
447
    notifierBox.remove();
1591
448
    notifierBox.destroy(true);
1592
449
  });
1593
450
1594
451
  // Assert the notifier box contains the expectedNumber of notifiers.
1595
452
  var assertNumNotifiers = function(expectedNumber) {
1596
453
    assert.equal(expectedNumber, notifierBox.get('children').size());
1597
454
  };
1598
455
1599
456
  it('should appear when a new error is notified', function() {
1600
457
    notifications.add({title: 'mytitle', level: 'error'});
1601
458
    assertNumNotifiers(1);
1602
459
  });
1603
460
1604
461
  it('should only appear when the DOM contains the notifier box', function() {
1605
462
    notifierBox.remove();
1606
463
    notifications.add({title: 'mytitle', level: 'error'});
1607
464
    assertNumNotifiers(0);
1608
465
  });
1609
466
1610
467
  it('should not appear when the notification is not an error', function() {
1611
468
    notifications.add({title: 'mytitle', level: 'info'});
1612
469
    assertNumNotifiers(0);
1613
470
  });
1614
471
1615
472
  it('should not appear when the notification comes form delta', function() {
1616
473
    notifications.add({title: 'mytitle', level: 'error', isDelta: true});
1617
474
    assertNumNotifiers(0);
1618
475
  });
1619
476
1620
477
});
1621
478
463
1622
=== modified file 'test/test_notifier_widget.js'
1623
--- test/test_notifier_widget.js	2012-11-16 13:37:20 +0000
1624
+++ test/test_notifier_widget.js	2012-11-20 23:07:20 +0000
1625
@@ -1,103 +1,101 @@
1626
1
'use strict';
1
'use strict';
1627
2
2
1683
3
describe('notifier widget', function() {
3
YUI(GlobalConfig).use(['notifier', 'node-event-simulate'], function(Y) {
1684
4
  var Notifier, notifierBox, Y;
4
  describe('notifier widget', function() {
1685
5
5
    var Notifier, notifierBox;
1686
6
  before(function(done) {
6
1687
7
    Y = YUI(GlobalConfig).use('notifier', 'node-event-simulate',
7
    before(function() {
1688
8
        function(Y) {
8
      Notifier = Y.namespace('juju.widgets').Notifier;
1689
9
          Notifier = Y.namespace('juju.widgets').Notifier;
9
    });
1690
10
          done();
10
1691
11
        });
11
    // Create the notifier box and attach it as first element of the body.
1692
12
  });
12
    beforeEach(function() {
1693
13
13
      notifierBox = Y.Node.create('<div id="notifier-box"></div>');
1694
14
  // Create the notifier box and attach it as first element of the body.
14
      notifierBox.setStyle('display', 'none');
1695
15
  beforeEach(function() {
15
      Y.one('body').prepend(notifierBox);
1696
16
    notifierBox = Y.Node.create('<div id="notifier-box"></div>');
16
    });
1697
17
    notifierBox.setStyle('display', 'none');
17
1698
18
    Y.one('body').prepend(notifierBox);
18
    // Destroy the notifier box created in beforeEach.
1699
19
  });
19
    afterEach(function() {
1700
20
20
      notifierBox.remove();
1701
21
  // Destroy the notifier box created in beforeEach.
21
      notifierBox.destroy(true);
1702
22
  afterEach(function() {
22
    });
1703
23
    notifierBox.remove();
23
1704
24
    notifierBox.destroy(true);
24
    // Factory rendering and returning a notifier instance.
1705
25
  });
25
    var makeNotifier = function(title, message, timeout) {
1706
26
26
      var notifier = new Notifier({
1707
27
  // Factory rendering and returning a notifier instance.
27
        title: title || 'mytitle',
1708
28
  var makeNotifier = function(title, message, timeout) {
28
        message: message || 'mymessage',
1709
29
    var notifier = new Notifier({
29
        timeout: timeout || 10000
1710
30
      title: title || 'mytitle',
30
      });
1711
31
      message: message || 'mymessage',
31
      notifier.render(notifierBox);
1712
32
      timeout: timeout || 10000
32
      return notifier;
1713
33
    });
33
    };
1714
34
    notifier.render(notifierBox);
34
1715
35
    return notifier;
35
    // Assert the notifier box contains the expectedNumber of notifiers.
1716
36
  };
36
    var assertNumNotifiers = function(expectedNumber) {
1717
37
37
      assert.equal(expectedNumber, notifierBox.get('children').size());
1718
38
  // Assert the notifier box contains the expectedNumber of notifiers.
38
    };
1719
39
  var assertNumNotifiers = function(expectedNumber) {
39
1720
40
    assert.equal(expectedNumber, notifierBox.get('children').size());
40
    it('should be able to display a notification', function() {
1666
41
  };
1667
42
1668
43
  it('should be able to display a notification', function() {
1669
44
    makeNotifier();
1670
45
    assertNumNotifiers(1);
1671
46
  });
1672
47
1673
48
  it('should display the given title and message', function() {
1674
49
    makeNotifier('mytitle', 'mymessage');
1675
50
    var notifierNode = notifierBox.one('*');
1676
51
    assert.equal('mytitle', notifierNode.one('h3').getContent());
1677
52
    assert.equal('mymessage', notifierNode.one('div').getContent());
1678
53
  });
1679
54
1680
55
  it('should be able to display multiple notifications', function() {
1681
56
    var number = 10;
1682
57
    for (var i = 0; i < number; i += 1) {
1721
58
      makeNotifier();
41
      makeNotifier();
1722
59
    }
1723
60
    assertNumNotifiers(number);
1724
61
  });
1725
62
1726
63
  it('should display new notifications on top', function() {
1727
64
    makeNotifier('mytitle1', 'mymessage1');
1728
65
    makeNotifier('mytitle2', 'mymessage2');
1729
66
    var notifierNode = notifierBox.one('*');
1730
67
    assert.equal('mytitle2', notifierNode.one('h3').getContent());
1731
68
    assert.equal('mymessage2', notifierNode.one('div').getContent());
1732
69
  });
1733
70
1734
71
  it('should destroy notifications after N milliseconds', function(done) {
1735
72
    makeNotifier('mytitle', 'mymessage', 1);
1736
73
    // A timeout of 250 milliseconds is used so that we ensure the destroying
1737
74
    // animation can be completed.
1738
75
    setTimeout(function() {
1739
76
      assertNumNotifiers(0);
1740
77
      done();
1741
78
    }, 250);
1742
79
  });
1743
80
1744
81
  it('should destroy notifications on click', function(done) {
1745
82
    makeNotifier();
1746
83
    notifierBox.one('*').simulate('click');
1747
84
    // A timeout of 250 milliseconds is used so that we ensure the destroying
1748
85
    // animation can be completed.
1749
86
    setTimeout(function() {
1750
87
      assertNumNotifiers(0);
1751
88
      done();
1752
89
    }, 250);
1753
90
  });
1754
91
1755
92
  it('should prevent notification removal on mouse enter', function(done) {
1756
93
    makeNotifier('mytitle', 'mymessage', 1);
1757
94
    notifierBox.one('*').simulate('mouseover');
1758
95
    // A timeout of 250 milliseconds is used so that we ensure the node is not
1759
96
    // preserved by the destroying animation.
1760
97
    setTimeout(function() {
1761
98
      assertNumNotifiers(1);
42
      assertNumNotifiers(1);
1764
99
      done();
43
    });
1765
100
    }, 250);
44
1766
45
    it('should display the given title and message', function() {
1767
46
      makeNotifier('mytitle', 'mymessage');
1768
47
      var notifierNode = notifierBox.one('*');
1769
48
      assert.equal('mytitle', notifierNode.one('h3').getContent());
1770
49
      assert.equal('mymessage', notifierNode.one('div').getContent());
1771
50
    });
1772
51
1773
52
    it('should be able to display multiple notifications', function() {
1774
53
      var number = 10;
1775
54
      for (var i = 0; i < number; i += 1) {
1776
55
        makeNotifier();
1777
56
      }
1778
57
      assertNumNotifiers(number);
1779
58
    });
1780
59
1781
60
    it('should display new notifications on top', function() {
1782
61
      makeNotifier('mytitle1', 'mymessage1');
1783
62
      makeNotifier('mytitle2', 'mymessage2');
1784
63
      var notifierNode = notifierBox.one('*');
1785
64
      assert.equal('mytitle2', notifierNode.one('h3').getContent());
1786
65
      assert.equal('mymessage2', notifierNode.one('div').getContent());
1787
66
    });
1788
67
1789
68
    it('should destroy notifications after N milliseconds', function(done) {
1790
69
      makeNotifier('mytitle', 'mymessage', 1);
1791
70
      // A timeout of 250 milliseconds is used so that we ensure the destroying
1792
71
      // animation can be completed.
1793
72
      setTimeout(function() {
1794
73
        assertNumNotifiers(0);
1795
74
        done();
1796
75
      }, 250);
1797
76
    });
1798
77
1799
78
    it('should destroy notifications on click', function(done) {
1800
79
      makeNotifier();
1801
80
      notifierBox.one('*').simulate('click');
1802
81
      // A timeout of 250 milliseconds is used so that we ensure the destroying
1803
82
      // animation can be completed.
1804
83
      setTimeout(function() {
1805
84
        assertNumNotifiers(0);
1806
85
        done();
1807
86
      }, 250);
1808
87
    });
1809
88
1810
89
    it('should prevent notification removal on mouse enter', function(done) {
1811
90
      makeNotifier('mytitle', 'mymessage', 1);
1812
91
      notifierBox.one('*').simulate('mouseover');
1813
92
      // A timeout of 250 milliseconds is used so that we ensure the node is not
1814
93
      // preserved by the destroying animation.
1815
94
      setTimeout(function() {
1816
95
        assertNumNotifiers(1);
1817
96
        done();
1818
97
      }, 250);
1819
98
    });
1820
99
1821
101
  });
100
  });
1822
102
1823
103
});
101
});
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2012-11-20	Pending
Review via email: mp+135198@code.launchpad.net