sproutcore 0.9.1 → 0.9.2

data/frameworks/sproutcore/tests/foundation/timer/invalidate.rhtml

@@ -0,0 +1,33 @@
+<% content_for('final') do %>
+
+<script>
+
+Test.context("Timer.invalidate", {
+
+  "invalidate immediately should never execute": function() {
+    
+    var fired = NO ;
+    
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+    var t = SC.Timer.schedule({
+      target: this,
+      action: function() { fired = YES ; },
+      interval: 100
+    });
+    t.invalidate() ;
+    SC.runLoop.endRunLoop() ;
+
+    var checks = 10 ;
+    wait(1500, function() {
+      assertEqual(NO, fired) ;
+    }) ;
+  }
+  
+  // using invalidate on a repeating timer is tested in schedule().
+
+});
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/foundation/timer/invokeLater.rhtml

@@ -0,0 +1,145 @@
+<% content_for('final') do %>
+
+<script>
+
+Test.context("SC.Object.invokeLater", {
+
+  "should invoke method string after specified time": function() {
+    var fired = NO ;
+    var o = SC.Object.create({
+      func: function() { fired = YES; }
+    }) ;
+    o.invokeLater('func', 200) ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should invoke method instance after specified time": function() {
+    var fired = NO ;
+    var o = SC.Object.create({
+      func: function() { fired = YES; }
+    }) ;
+    o.invokeLater(o.func, 200) ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should invoke method string immediately if no time passed": function() {
+    var fired = NO ;
+    var o = SC.Object.create({
+      func: function() { fired = YES; }
+    }) ;
+    o.invokeLater('func') ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should automatically bind with arguments if passed": function() {
+    var fired = NO ;
+    var g1 = null, g2 = null ;
+    
+    var o = SC.Object.create({
+      func: function(arg1, arg2) { 
+        g1 = arg1; g2 = arg2; fired = YES; 
+      }
+    }) ;
+    o.invokeLater('func', 200, 'ARG1', 'ARG2') ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+      assertEqual('ARG1', g1, 'arg1');
+      assertEqual('ARG2', g2, 'arg2'); 
+    } ;
+    wait(300, f) ;
+  }
+
+});
+
+Test.context("Prototype.invokeLater", {
+
+  "should invoke function with target after specified time": function() {
+    var fired = NO ;
+    var target = null;
+    var o = SC.Object.create() ;
+    var func = function() { fired = YES; target = this; } ; 
+    func.invokeLater(o, 200) ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+      assertEqual(o, target, 'target') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should invoke object with no target after specified time": function() {
+    var fired = NO ;
+    var func = function() { fired = YES; } ; 
+    func.invokeLater(null, 200) ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should invoke function immediately if no time passed": function() {
+    var fired = NO ;
+    var o = SC.Object.create() ;
+    var func = function() { fired = YES; } ; 
+    func.invokeLater(o) ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+    } ;
+    wait(300, f) ;
+  },
+  
+  "should automatically bind with arguments if passed": function() {
+    var fired = NO ;
+    var g1 = null, g2 = null ;
+
+    var o = SC.Object.create() ;
+    var func = function(arg1, arg2) { 
+      g1 = arg1; g2 = arg2; fired = YES; 
+    } ; 
+    func.invokeLater(o, 200, 'ARG1', 'ARG2') ;
+    
+    var tries = 20;
+    var f= function() {
+      if (!fired && --tries >= 0) wait(100, f) ;
+      assertEqual(YES, fired, 'did not fire') ;
+      assertEqual('ARG1', g1, 'arg1');
+      assertEqual('ARG2', g2, 'arg2'); 
+    } ;
+    wait(300, f) ;
+  }
+
+
+});
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/foundation/timer/isPaused.rhtml

@@ -0,0 +1,70 @@
+<% content_for('final') do %>
+
+<script>
+
+Test.context("Timer.isPaused", {
+
+  "setting isPaused should stop firing": function() {
+    
+    var firedCount = 0 ;
+    
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+    var t = SC.Timer.schedule({
+      target: this,
+      action: function() { firedCount++ ; },
+      interval: 100,
+      repeats: YES
+    });
+    SC.runLoop.endRunLoop() ;
+
+    // wait for timer to fire twice, then pause it.
+    var tries1 = 10 ;
+    var f1 = function() {
+      if(firedCount<2) {
+        if (--tries1 >= 0) {
+          wait(100, f1) ;
+        } else assertEqual(NO, YES, 'Timer never fired 2 times - f1') ;
+      } else {
+        assertEqual(NO, t.get('isPaused'), 'should start with isPaused = NO');
+        t.set('isPaused', YES) ;
+        firedCount = 0 ; // Reset count here.
+        wait(300, f2) ;
+      }
+    };
+    
+    // once timer paused, make sure it did not fire again.
+    var f2 = function() {
+      assertEqual(0, firedCount, 'timer kept firing!') ;
+      assertEqual(YES, t.get('isPaused'), 'timer is not paused') ;
+      t.set('isPaused', NO) ;
+      
+      wait(300, f3) ;
+    } ;
+    
+    // once timer has verified paused, unpause and make sure it fires again.
+    var tries2 = 10 ;
+    var f3 = function() {
+      if (firedCount <= 2) {
+        if (--tries1 >= 0) {
+          wait(100, f3) ;
+        } else assertEqual(NO, YES, "Timer did not resume") ;
+        
+      // timer fired, clean up.
+      } else {
+        t.invalidate() ;
+        assertEqual(NO, t.get('isPaused'), 'timer did not unpause') ;
+      }
+    };
+    
+    wait(300, f1) ;
+    
+  }
+  
+  // using invalidate on a repeating timer is tested in schedule().
+
+});
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/foundation/timer/schedule.rhtml

@@ -0,0 +1,145 @@
+<% content_for('final') do %>
+
+<script>
+
+Test.context("Timer.schedule single timer", {
+
+  "single timer should execute once and invalidate": function() {
+    var fired = [] ;
+    
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+    var t = SC.Timer.schedule({
+      target: this,
+      action: function() { fired.push(Date.now()); },
+      interval: 100, 
+      repeats: NO
+    });
+    SC.runLoop.endRunLoop() ;
+
+    var checks = 10 ;
+    var f = function() {
+      
+      if (fired.length == 0 && --checks > 0) {
+        wait(100, f); return ;
+      }
+      
+      // should only fire once
+      assertEqual(1, fired.length, 'fired count') ;
+      
+      // timer should no longer be valid
+      assertEqual(NO, t.get('isValid'), 'isValid');
+  
+    } ;
+    
+    wait(300, f);
+  },
+
+  "repeating timer with no limit should repeat until terminated": function() {
+    var fired = [] ;
+
+    // schedule repeating timer
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+    var runs = 4 ;
+    
+    var t = SC.Timer.schedule({
+      target: this,
+      action: function() { 
+        fired.push(Date.now()); 
+        if (--runs <= 0) t.invalidate(); 
+      },
+      interval: 100, 
+      repeats: YES
+    });
+    SC.runLoop.endRunLoop() ;
+
+    // We can't gaurantee when timeouts will execute in the browser so we 
+    // have to be a little flexible about testing repeated loops like this.
+    var checks = 10 ;
+    var f = function() {
+
+      if (--checks < 0) assertEqual(YES, NO, 'Check Count Exceeded') ;
+      if (runs > 0) {
+        wait(100, f) ; // wait until timer fires 4 times.
+      } else {
+        var diffs = fired.map(function(x) { return x - start; });
+        assertEqual(4, fired.length, 'fired count: %@'.fmt(diffs.join(', '))) ;
+        assertEqual(NO, t.get('isValid'), 'isValid') ;
+      }
+    };
+    wait(600, f);
+    
+  },
+  
+  "repeating timer should terminate after expiration": function() {
+    var fired = [] ;
+
+    // schedule repeating timer
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+    var runs = 4 ;
+    
+    var t = SC.Timer.schedule({
+      target: this,
+      action: function() { 
+        fired.push(Date.now()); 
+      },
+      interval: 100, 
+      repeats: YES,
+      until: start + 500
+    });
+    SC.runLoop.endRunLoop() ;
+
+    // We can't gaurantee when timeouts will execute in the browser so we 
+    // have to be a little flexible about testing repeated loops like this.
+    var checks = 10 ;
+    var f = function() {
+      if (--checks < 0) assertEqual(YES, NO, 'Timer never invalidated :') ;
+      if ((checks > 0) && t.get('isValid')) {
+        wait(100, f); 
+      } else {
+        var diffs = fired.map(function(x) { return x - start; });
+        assertEqual(NO, t.get('isValid'), 'Timer did not terminate: %@'.fmt(diffs.join(', '))) ;
+      }
+    };
+    wait(600, f);
+  },
+  
+  "scheduling multiple timers at the same time should cause them to fire at same time": function() {
+    
+    var f1 = 0; var f2 = 0;
+    SC.runLoop.beginRunLoop() ;
+    var start = SC.runLoop.get('startTime') ;
+
+    var t1 = SC.Timer.schedule({
+      target: this, 
+      action: function() { f1 = SC.runLoop.get('startTime'); },
+      interval: 100
+    });
+
+    var t2 = SC.Timer.schedule({
+      target: this, 
+      action: function() { f2 = SC.runLoop.get('startTime'); },
+      interval: 100
+    });
+
+    // be lenient on execution time since we can't control the browser.
+    var tries = 10 ;
+    var f = function() {
+      if ((f1 == 0 || f2 == 0) && --tries >= 0) {
+        wait(100, f) ; return ;
+      }
+      
+      assertEqual(f1, f2, 'execution time f1 == f2');
+      assertEqual(NO, t1.get('isValid'), 't1.isValid') ;
+      assertEqual(NO, t2.get('isValid'), 't2.isValid') ;
+    } ;
+    wait(200, f) ;
+  }
+
+});
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/views/{scroll.rhtml → checkbox.rhtml}

@@ -1,12 +1,12 @@
 <% # ========================================================================
-   # Sproutcore.ScrollView Unit Test
+   # SC.CheckboxView Unit Test
    # ========================================================================
 %>
 <% content_for('final') do %>
 
 <script>
 
-Test.context("Sproutcore.ScrollView",{
+Test.context("SC.CheckboxView",{
 
   "TODO: Add your own tests here": function() {
     true.shouldEqual(true) ;
@@ -14,7 +14,7 @@ Test.context("Sproutcore.ScrollView",{
 
 }) ;
 
-appMain = main; main = null ; // Cancel main() so app does not start
+if (window.main && (appMain = main)) main = null ; 
 
 </script>
 

data/frameworks/sproutcore/tests/views/{collection.rhtml → collection/base.rhtml}

@@ -3,38 +3,53 @@
 
 Test.context("A SC.CollectionView with it's content set to a SC.CollectionController", {
   
-  "Should contain the same number of item views as it's controller has records": function()
+  "Should contain the same number of visible item views": function()
   {
-    testCollectionView.get('itemViews').length.shouldEqual(6);
+    testCollectionView.get('itemViews').length.shouldEqual(2);
   },
+  
   "Should update it's item views as it's controller is updated": function()
   {
-    testCollectionView.get('itemViews').length.shouldEqual(6);
-    SC.Store.addRecord( SC.Record.create({ guid: '1007', name: 'item seven' }) );
-    testCollectionView.get('itemViews').length.shouldEqual(7);
+    var valueOfFirstItemView = function() {
+      var itemView = testCollectionView.get('itemViews').first() ;
+      return (itemView) ? itemView.get('content').get('guid') : null ;
+    } ;
+    
+    valueOfFirstItemView().shouldEqual('1001') ;
+
+    SC.Store.addRecord( SC.Record.create({ guid: '0999', name: 'item zero' }) );
+    
+    valueOfFirstItemView().shouldEqual('0999') ;
   },
+
   "Should scroll to the selected item": function()
   {
-    testCollection.get('records').length.shouldEqual(6);
     testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
-    testCollectionView.scrollToItemRecord( testCollection.get('records').last() );
-    testCollectionView.get('rootElement').scrollTop.shouldEqual(30);
+    testCollectionView.scrollToContent( testCollection.get('records').last() );
+    scrollView.get('rootElement').scrollTop.shouldEqual(30);
   },
+
   "Should not scroll to the selected item if it's already fully visible": function()
   {
-    testCollection.get('records').length.shouldEqual(6);
-    testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
-    testCollectionView.scrollToItemRecord( testCollection.get('records')[1] );
-    testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
+    scrollView.get('rootElement').scrollTop.shouldEqual(0);
+    testCollectionView.scrollToContent( testCollection.get('records')[1] );
+    scrollView.get('rootElement').scrollTop.shouldEqual(0);
   },
+
   setup: function()
   {
+    // add a scroll view wrapper.
+    scrollView = SC.ScrollView.create() ;
+    scrollView.set('frame', { x: 10, y: 10, width: 100, height: 30 });
+    SC.window.appendChild(scrollView);
+    
     // create the view...
-    testCollectionView = SC.CollectionView.extend({
+    testCollectionView = SC.ListView.extend({
+      contentValueKey: 'name',
       contentBinding: 'testController.arrangedObjects',
       selectionBinding: 'testController.selection'
     }).create();
-    SC.window.appendChild(testCollectionView);
+    scrollView.set('content', testCollectionView) ;
     
     // create some item data...
     [
@@ -54,36 +69,25 @@ Test.context("A SC.CollectionView with it's content set to a SC.CollectionContro
     testController = SC.CollectionController.create();
     testController.set('content', testCollection);
     
-    
-    // make the view scrollable.
-    var element = Element.extend(testCollectionView.get('rootElement'));
-    element.setStyle({ overflow: 'auto', width: '100px', height: '30px' });
-    // set the item heights to force the collection to scroll
-    element.childElements().each(function(child)
-    {
-      child.setStyle({ height: '10px' });
-    });
   },
   teardown: function()
   {
     // tell SC.Store to dump all the records... 
     // otherwise, since SC.Store is shared across all tests (yuk!) we'll get shared fixtues
     testCollection.get('records').each(function(r){ SC.Store.removeRecord(r); });
-
+  
     // remove the view from SC.window... again, no shared fixtures...
     testCollectionView.removeFromParent();
-
+    scrollView.removeFromParent() ;
+  
     delete testCollectionView;
     delete testCollection;
     delete testController;
+    delete scrollView ;
   }
   
 });
 
-
-
-
-
 Test.context("A SC.CollectionView with it's content set to a SC.ArrayController",
 {
   "Should contain the same number of item views as it's controller has records": function()
@@ -130,8 +134,5 @@ Test.context("A SC.CollectionView with it's content set to a SC.ArrayController"
   }
 });
 
-
-
-
 </script>
 <% end %>