moved all uneeded files out, widgets.html works, tests horribly broken

6 files changed, 823 insertions, 0 deletions

diff --git a/test/moveToAngularCom/Base64Test.js b/test/moveToAngularCom/Base64Test.js
new file mode 100644
index 00000000..a9353186
--- /dev/null
+++ b/test/moveToAngularCom/Base64Test.js
@@ -0,0 +1,5 @@
+Base64Test = TestCase('Base64Test');
+
+Base64Test.prototype.testEncodeDecode = function(){
+  assertEquals(Base64.decode(Base64.encode('hello')), 'hello');
+};
diff --git a/test/moveToAngularCom/DataStoreTest.js b/test/moveToAngularCom/DataStoreTest.js
new file mode 100644
index 00000000..87c5be2e
--- /dev/null
+++ b/test/moveToAngularCom/DataStoreTest.js
@@ -0,0 +1,616 @@
+DataStoreTest = TestCase('DataStoreTest');
+
+DataStoreTest.prototype.testSavePostsToServer = function(){
+  expectAsserts(10);
+  var response;
+  var post = function(data, callback){
+    var method = data[0][0];
+    var posted = data[0][2];
+    assertEquals("POST", method);
+    assertEquals("abc", posted.$entity);
+    assertEquals("123", posted.$id);
+    assertEquals("1", posted.$version);
+    assertFalse('function' == typeof posted.save);
+    response = fromJson(toJson(posted));
+    response.$entity = "abc";
+    response.$id = "123";
+    response.$version = "2";
+    callback(200, [response]);
+  };
+  var datastore = new DataStore(post);
+  var model = datastore.entity('abc', {name: "value"})();
+  model.$id = "123";
+  model.$version = "1";
+
+  datastore.save(model, function(obj){
+    assertTrue(obj === model);
+    assertEquals(obj.$entity, "abc");
+    assertEquals(obj.$id, "123");
+    assertEquals(obj.$version, "2");
+    assertEquals(obj.name, "value");
+    obj.after = true;
+  });
+  datastore.flush();
+};
+
+DataStoreTest.prototype.testLoadGetsFromServer = function(){
+  expectAsserts(12);
+  var post = function(data, callback){
+      var method = data[0][0];
+      var path = data[0][1];
+      assertEquals("GET", method);
+      assertEquals("abc/1", path);
+      response = [{$entity:'abc', $id:'1', $version:'2', key:"value"}];
+      callback(200, response);
+    };
+  var datastore = new DataStore(post);
+
+  var model = datastore.entity("abc", {merge:true})();
+  assertEquals(datastore.load(model, '1', function(obj){
+    assertEquals(obj.$entity, "abc");
+    assertEquals(obj.$id, "1");
+    assertEquals(obj.$version, "2");
+    assertEquals(obj.key, "value");
+  }), model);
+  datastore.flush();
+  assertEquals(model.$entity, "abc");
+  assertEquals(model.$id, "1");
+  assertEquals(model.$version, "2");
+  assertEquals(model.key, "value");
+  assertEquals(model.merge, true);
+};
+
+DataStoreTest.prototype.testRemove = function(){
+  expectAsserts(8);
+  var response;
+  var post = function(data, callback){
+    var method = data[0][0];
+    var posted = data[0][2];
+    assertEquals("DELETE", method);
+    assertEquals("abc", posted.$entity);
+    assertEquals("123", posted.$id);
+    assertEquals("1", posted.$version);
+    assertFalse('function' == typeof posted.save);
+    response = fromJson(toJson(posted));
+    response.$entity = "abc";
+    response.$id = "123";
+    response.$version = "2";
+    callback(200, [response]);
+  };
+  var model;
+  var datastore = new DataStore(post);
+  model = datastore.entity('abc', {name: "value"})();
+  model.$id = "123";
+  model.$version = "1";
+
+  datastore.remove(model, function(obj){
+    assertEquals(obj.$id, "123");
+    assertEquals(obj.$version, "2");
+    assertEquals(obj.name, "value");
+    obj.after = true;
+  });
+  datastore.flush();
+
+};
+
+
+DataStoreTest.prototype.test401ResponseDoesNotCallCallback = function(){
+  expectAsserts(1);
+  var post = function(data, callback) {
+    callback(200, {$status_code: 401});
+  };
+
+  var datastore = new DataStore(post, {login:function(){
+    assertTrue(true);
+  }});
+
+  var onLoadAll = function(){
+    assertTrue(false, "onLoadAll should not be called when response is status 401");
+  };
+  datastore.bulkRequest.push({});
+  datastore.flush();
+  datastore.loadAll({type: "A"}, onLoadAll);
+};
+
+DataStoreTest.prototype.test403ResponseDoesNotCallCallback = function(){
+  expectAsserts(1);
+  var post = function(data, callback) {
+    callback(200, [{$status_code: 403}]);
+  };
+
+  var datastore = new DataStore(post, {notAuthorized:function(){
+    assertTrue(true);
+  }});
+
+  var onLoadAll = function(){
+    assertTrue(false, "onLoadAll should not be called when response is status 403");
+  };
+  datastore.bulkRequest.push({});
+  datastore.flush();
+  datastore.loadAll({type: "A"}, onLoadAll);
+};
+
+DataStoreTest.prototype.testLoadCalledWithoutIdShouldBeNoop = function(){
+  expectAsserts(2);
+  var post = function(url, callback){
+    assertTrue(false);
+  };
+  var datastore = new DataStore(post);
+  var model = datastore.entity("abc")();
+  assertEquals(datastore.load(model, undefined), model);
+  assertEquals(model.$entity, "abc");
+};
+
+DataStoreTest.prototype.testEntityFactory = function(){
+  var ds = new DataStore();
+  var Recipe = ds.entity("Recipe", {a:1, b:2});
+  assertEquals(Recipe.title, "Recipe");
+  assertEquals(Recipe.defaults.a, 1);
+  assertEquals(Recipe.defaults.b, 2);
+
+  var recipe = Recipe();
+  assertEquals(recipe.$entity, "Recipe");
+  assertEquals(recipe.a, 1);
+  assertEquals(recipe.b, 2);
+
+  recipe = new Recipe();
+  assertEquals(recipe.$entity, "Recipe");
+  assertEquals(recipe.a, 1);
+  assertEquals(recipe.b, 2);
+};
+
+DataStoreTest.prototype.testEntityFactoryNoDefaults = function(){
+  var ds = new DataStore();
+  var Recipe = ds.entity("Recipe");
+  assertEquals(Recipe.title, "Recipe");
+
+  recipe = new Recipe();
+  assertEquals(recipe.$entity, "Recipe");
+};
+
+DataStoreTest.prototype.testEntityFactoryWithInitialValues = function(){
+  var ds = new DataStore();
+  var Recipe = ds.entity("Recipe");
+
+  var recipe = Recipe({name: "name"});
+  assertEquals("name", recipe.name);
+};
+
+DataStoreTest.prototype.testEntityLoad = function(){
+  var ds = new DataStore();
+  var Recipe = ds.entity("Recipe", {a:1, b:2});
+  ds.load = function(instance, id, callback){
+    callback.apply(instance);
+    return instance;
+  };
+  var instance = null;
+  var recipe2 = Recipe.load("ID", function(){
+    instance = this;
+  });
+  assertTrue(recipe2 === instance);
+};
+
+DataStoreTest.prototype.testSaveScope = function(){
+  var ds = new DataStore();
+  var log = "";
+  var Person = ds.entity("Person");
+  var person1 = Person({name:"A", $entity:"Person", $id:"1", $version:"1"}, ds);
+  person1.$$anchor = "A";
+  var person2 = Person({name:"B", $entity:"Person", $id:"2", $version:"2"}, ds);
+  person2.$$anchor = "B";
+  var anchor = {};
+  ds.anchor = anchor;
+  ds._jsonRequest = function(request, callback){
+    log += "save(" + request[2].$id + ");";
+    callback({$id:request[2].$id});
+  };
+  ds.saveScope({person1:person1, person2:person2,
+        ignoreMe:{name: "ignore", save:function(callback){callback();}}}, function(){
+    log += "done();";
+  });
+  assertEquals("save(1);save(2);done();", log);
+  assertEquals(1, anchor.A);
+  assertEquals(2, anchor.B);
+};
+
+DataStoreTest.prototype.testEntityLoadAllRows = function(){
+  var ds = new DataStore();
+  var Recipe = ds.entity("Recipe");
+  var list = [];
+  ds.loadAll = function(entity, callback){
+    assertTrue(Recipe === entity);
+    callback.apply(list);
+    return list;
+  };
+  var items = Recipe.all(function(){
+    assertTrue(list === this);
+  });
+  assertTrue(items === list);
+};
+
+DataStoreTest.prototype.testLoadAll = function(){
+  expectAsserts(8);
+  var post = function(data, callback){
+    assertEquals("GET", data[0][0]);
+    assertEquals("A", data[0][1]);
+    callback(200, [[{$entity:'A', $id:'1'},{$entity:'A', $id:'2'}]]);
+  };
+  var datastore = new DataStore(post);
+  var list = datastore.entity("A").all(function(){
+    assertTrue(true);
+  });
+  datastore.flush();
+  assertEquals(list.length, 2);
+  assertEquals(list[0].$entity, "A");
+  assertEquals(list[0].$id, "1");
+  assertEquals(list[1].$entity, "A");
+  assertEquals(list[1].$id, "2");
+};
+
+DataStoreTest.prototype.testQuery = function(){
+  expectAsserts(5);
+  var post = function(data, callback) {
+    assertEquals("GET", data[0][0]);
+    assertEquals("Employee/managerId=123abc", data[0][1]);
+    callback(200, [[{$entity:"Employee", $id: "456", managerId: "123ABC"}]]);
+
+  };
+  var datastore = new DataStore(post);
+  var Employee = datastore.entity("Employee");
+  var list = Employee.query('managerId', "123abc", function(){
+    assertTrue(true);
+  });
+  datastore.flush();
+  assertJsonEquals([[{$entity:"Employee", $id: "456", managerId: "123ABC"}]], datastore._cache.$collections);
+  assertEquals(list[0].$id, "456");
+};
+
+DataStoreTest.prototype.testLoadingDocumentRefreshesExistingArrays = function() {
+  expectAsserts(12);
+  var post;
+  var datastore = new DataStore(function(r, c){post(r,c);});
+  var Book = datastore.entity('Book');
+  post = function(req, callback) {
+    callback(200, [[{$id:1, $entity:"Book", name:"Moby"},
+                    {$id:2, $entity:"Book", name:"Dick"}]]);
+  };
+  var allBooks = Book.all();
+  datastore.flush();
+  var queryBooks = Book.query("a", "b");
+  datastore.flush();
+  assertEquals("Moby", allBooks[0].name);
+  assertEquals("Dick", allBooks[1].name);
+  assertEquals("Moby", queryBooks[0].name);
+  assertEquals("Dick", queryBooks[1].name);
+
+  post = function(req, callback) {
+    assertEquals('[["GET","Book/1"]]', toJson(req));
+    callback(200, [{$id:1, $entity:"Book", name:"Moby Dick"}]);
+  };
+  var book = Book.load(1);
+  datastore.flush();
+  assertEquals("Moby Dick", book.name);
+  assertEquals("Moby Dick", allBooks[0].name);
+  assertEquals("Moby Dick", queryBooks[0].name);
+
+  post = function(req, callback) {
+    assertEquals('POST', req[0][0]);
+    callback(200, [{$id:1, $entity:"Book", name:"The Big Fish"}]);
+  };
+  book.$save();
+  datastore.flush();
+  assertEquals("The Big Fish", book.name);
+  assertEquals("The Big Fish", allBooks[0].name);
+  assertEquals("The Big Fish", queryBooks[0].name);
+};
+
+DataStoreTest.prototype.testEntityProperties = function() {
+  expectAsserts(2);
+  var datastore = new DataStore();
+  var callback = {};
+
+  datastore._jsonRequest = function(request, callbackFn) {
+    assertJsonEquals(["GET", "Cheese/$properties"], request);
+    assertEquals(callback, callbackFn);
+  };
+
+  var Cheese = datastore.entity("Cheese");
+  Cheese.properties(callback);
+
+};
+
+DataStoreTest.prototype.testLoadInstanceIsNotFromCache = function() {
+  var post;
+  var datastore = new DataStore(function(r, c){post(r,c);});
+  var Book = datastore.entity('Book');
+
+  post = function(req, callback) {
+    assertEquals('[["GET","Book/1"]]', toJson(req));
+    callback(200, [{$id:1, $entity:"Book", name:"Moby Dick"}]);
+  };
+  var book = Book.load(1);
+  datastore.flush();
+  assertEquals("Moby Dick", book.name);
+  assertFalse(book === datastore._cache['Book/1']);
+};
+
+DataStoreTest.prototype.testLoadStarsIsNewDocument = function() {
+  var datastore = new DataStore();
+  var Book = datastore.entity('Book');
+  var book = Book.load('*');
+  assertEquals('Book', book.$entity);
+};
+
+DataStoreTest.prototype.testUndefinedEntityReturnsNullValueObject = function() {
+  var datastore = new DataStore();
+  var Entity = datastore.entity(undefined);
+  var all = Entity.all();
+  assertEquals(0, all.length);
+};
+
+DataStoreTest.prototype.testFetchEntities = function(){
+  expectAsserts(6);
+  var post = function(data, callback){
+    assertJsonEquals(["GET", "$entities"], data[0]);
+    callback(200, [{A:0, B:0}]);
+  };
+  var datastore = new DataStore(post);
+  var entities = datastore.entities(function(){
+    assertTrue(true);
+  });
+  datastore.flush();
+  assertJsonEquals([], datastore.bulkRequest);
+  assertEquals(2, entities.length);
+  assertEquals("A", entities[0].title);
+  assertEquals("B", entities[1].title);
+};
+
+DataStoreTest.prototype.testItShouldMigrateSchema = function() {
+  var datastore = new DataStore();
+  var Entity = datastore.entity("Entity", {a:[], user:{name:"Misko", email:""}});
+  var doc = Entity().$loadFrom({b:'abc', user:{email:"misko@hevery.com"}});
+  assertFalse(
+      toJson({a:[], b:'abc', user:{name:"Misko", email:"misko@hevery.com"}}) ==
+      toJson(doc));
+  doc.$migrate();
+  assertEquals(
+      toJson({a:[], b:'abc', user:{name:"Misko", email:"misko@hevery.com"}}),
+      toJson(doc));
+};
+
+DataStoreTest.prototype.testItShouldCollectRequestsForBulk = function() {
+  var ds = new DataStore();
+  var Book = ds.entity("Book");
+  var Library = ds.entity("Library");
+  Book.all();
+  Library.load("123");
+  assertEquals(2, ds.bulkRequest.length);
+  assertJsonEquals(["GET", "Book"], ds.bulkRequest[0]);
+  assertJsonEquals(["GET", "Library/123"], ds.bulkRequest[1]);
+};
+
+DataStoreTest.prototype.testEmptyFlushShouldDoNothing = function () {
+  var ds = new DataStore(function(){
+    fail("expecting noop");
+  });
+  ds.flush();
+};
+
+DataStoreTest.prototype.testFlushShouldCallAllCallbacks = function() {
+  var log = "";
+  function post(request, callback){
+    log += 'BulkRequest:' + toJson(request) + ';';
+    callback(200, [[{$id:'ABC'}], {$id:'XYZ'}]);
+  }
+  var ds = new DataStore(post);
+  var Book = ds.entity("Book");
+  var Library = ds.entity("Library");
+  Book.all(function(instance){
+    log += toJson(instance) + ';';
+  });
+  Library.load("123", function(instance){
+    log += toJson(instance) + ';';
+  });
+  assertEquals("", log);
+  ds.flush();
+  assertJsonEquals([], ds.bulkRequest);
+  assertEquals('BulkRequest:[["GET","Book"],["GET","Library/123"]];[{"$id":"ABC"}];{"$id":"XYZ"};', log);
+};
+
+DataStoreTest.prototype.testSaveOnNotLoggedInRetriesAfterLoggin = function(){
+  var log = "";
+  var book;
+  var ds = new DataStore(null, {login:function(c){c();}});
+  ds.post = function (request, callback){
+    assertJsonEquals([["POST", "", book]], request);
+    ds.post = function(request, callback){
+      assertJsonEquals([["POST", "", book]], request);
+      ds.post = function(){fail("too much recursion");};
+      callback(200, [{saved:"ok"}]);
+    };
+    callback(200, {$status_code:401});
+  };
+  book = ds.entity("Book")({name:"misko"});
+  book.$save();
+  ds.flush();
+  assertJsonEquals({saved:"ok"}, book);
+};
+
+DataStoreTest.prototype.testItShouldRemoveItemFromCollectionWhenDeleted = function() {
+  expectAsserts(6);
+  var ds = new DataStore();
+  ds.post = function(request, callback){
+    assertJsonEquals([["GET", "Book"]], request);
+    callback(200, [[{name:"Moby Dick", $id:123, $entity:'Book'}]]);
+  };
+  var Book = ds.entity("Book");
+  var books = Book.all();
+  ds.flush();
+  assertJsonEquals([[{name:"Moby Dick", $id:123, $entity:'Book'}]], ds._cache.$collections);
+  assertDefined(ds._cache['Book/123']);
+  var book = Book({$id:123});
+  ds.post = function(request, callback){
+    assertJsonEquals([["DELETE", "", book]], request);
+    callback(200, [book]);
+  };
+  ds.remove(book);
+  ds.flush();
+  assertUndefined(ds._cache['Book/123']);
+  assertJsonEquals([[]],ds._cache.$collections);
+};
+
+DataStoreTest.prototype.testItShouldAddToAll = function() {
+  expectAsserts(8);
+  var ds = new DataStore();
+  ds.post = function(request, callback){
+    assertJsonEquals([["GET", "Book"]], request);
+    callback(200, [[]]);
+  };
+  var Book = ds.entity("Book");
+  var books = Book.all();
+  assertEquals(0, books.length);
+  ds.flush();
+  var moby = Book({name:'moby'});
+  moby.$save();
+  ds.post = function(request, callback){
+    assertJsonEquals([["POST", "", moby]], request);
+    moby.$id = '123';
+    callback(200, [moby]);
+  };
+  ds.flush();
+  assertEquals(1, books.length);
+  assertEquals(moby, books[0]);
+  
+  moby.$save();
+  ds.flush();
+  assertEquals(1, books.length);
+  assertEquals(moby, books[0]);
+};
+
+DataStoreTest.prototype.testItShouldReturnCreatedDocumentCountByUser = function(){
+  expectAsserts(2);
+  var datastore = new DataStore(
+      function(request, callback){
+        assertJsonEquals([["GET", "$users"]], request);
+        callback(200, [{misko:1, adam:1}]);
+      });
+  var users = datastore.documentCountsByUser();
+  assertJsonEquals({misko:1, adam:1}, users);
+};
+
+
+DataStoreTest.prototype.testItShouldReturnDocumentIdsForUeserByEntity = function(){
+  expectAsserts(2);
+  var datastore = new DataStore(
+      function(request, callback){
+        assertJsonEquals([["GET", "$users/misko@hevery.com"]], request);
+        callback(200, [{Book:["1"], Library:["2"]}]);
+      });
+  var users = datastore.userDocumentIdsByEntity("misko@hevery.com");
+  assertJsonEquals({Book:["1"], Library:["2"]}, users);
+};
+
+DataStoreTest.prototype.testItShouldReturnNewInstanceOn404 = function(){
+  expectAsserts(7);
+  var log = "";
+  var datastore = new DataStore(
+      function(request, callback){
+        assertJsonEquals([["GET", "User/misko"]], request);
+        callback(200, [{$status_code:404}]);
+      });
+  var User = datastore.entity("User", {admin:false});
+  var user = User.loadOrCreate('misko', function(i){log+="cb "+i.$id+";";});
+  datastore.flush();
+  assertEquals("misko", user.$id);
+  assertEquals("User", user.$entity);
+  assertEquals(false, user.admin);
+  assertEquals("undefined", typeof user.$secret);
+  assertEquals("undefined", typeof user.$version);
+  assertEquals("cb misko;", log);
+};
+
+DataStoreTest.prototype.testItShouldReturnNewInstanceOn404 = function(){
+  var log = "";
+  var datastore = new DataStore(
+      function(request, callback){
+        assertJsonEquals([["GET", "User/misko"],["GET", "User/adam"]], request);
+        callback(200, [{$id:'misko'},{$id:'adam'}]);
+      });
+  var User = datastore.entity("User");
+  var users = User.loadMany(['misko', 'adam'], function(i){log+="cb "+toJson(i)+";";});
+  datastore.flush();
+  assertEquals("misko", users[0].$id);
+  assertEquals("adam", users[1].$id);
+  assertEquals('cb [{"$id":"misko"},{"$id":"adam"}];', log);
+};
+
+DataStoreTest.prototype.testItShouldCreateJoinAndQuery = function() {
+  var datastore = new DataStore();
+  var Invoice = datastore.entity("Invoice");
+  var Customer = datastore.entity("Customer");
+  var InvoiceWithCustomer = datastore.join({
+    invoice:{join:Invoice},
+    customer:{join:Customer, on:"invoice.customer"}
+  });
+  var invoiceWithCustomer = InvoiceWithCustomer.query("invoice.month", 1);
+  assertEquals([], invoiceWithCustomer);
+  assertJsonEquals([["GET", "Invoice/month=1"]], datastore.bulkRequest);
+  var request = datastore.bulkRequest.shift();
+  request.$$callback([{$id:1, customer:1},{$id:2, customer:1},{$id:3, customer:3}]);
+  assertJsonEquals([["GET","Customer/1"],["GET","Customer/3"]], datastore.bulkRequest);
+  datastore.bulkRequest.shift().$$callback({$id:1});
+  datastore.bulkRequest.shift().$$callback({$id:3});
+  assertJsonEquals([
+    {invoice:{$id:1,customer:1},customer:{$id:1}},
+    {invoice:{$id:2,customer:1},customer:{$id:1}},
+    {invoice:{$id:3,customer:3},customer:{$id:3}}], invoiceWithCustomer);
+};
+
+DataStoreTest.prototype.testItShouldThrowIfMoreThanOneEntityIsPrimary = function() {
+  var datastore = new DataStore();
+  var Invoice = datastore.entity("Invoice");
+  var Customer = datastore.entity("Customer");
+  assertThrows("Exactly one entity needs to be primary.", function(){
+    datastore.join({
+      invoice:{join:Invoice},
+      customer:{join:Customer}
+    });
+  });  
+};
+
+DataStoreTest.prototype.testItShouldThrowIfLoopInReferences = function() {
+  var datastore = new DataStore();
+  var Invoice = datastore.entity("Invoice");
+  var Customer = datastore.entity("Customer");
+  assertThrows("Infinite loop in join: invoice -> customer", function(){
+    datastore.join({
+      invoice:{join:Invoice, on:"customer.invoice"},
+      customer:{join:Customer, on:"invoice.customer"}
+    });
+  });
+};
+
+DataStoreTest.prototype.testItShouldThrowIfReferenceToNonExistantJoin = function() {
+  var datastore = new DataStore();
+  var Invoice = datastore.entity("Invoice");
+  var Customer = datastore.entity("Customer");
+  assertThrows("Named entity 'x' is undefined.", function(){
+    datastore.join({
+      invoice:{join:Invoice, on:"x.invoice"},
+      customer:{join:Customer, on:"invoice.customer"}
+    });
+  });  
+};
+
+DataStoreTest.prototype.testItShouldThrowIfQueryOnNonPrimary = function() {
+  var datastore = new DataStore();
+  var Invoice = datastore.entity("Invoice");
+  var Customer = datastore.entity("Customer");
+  var InvoiceWithCustomer = datastore.join({
+    invoice:{join:Invoice},
+    customer:{join:Customer, on:"invoice.customer"}
+  });
+  assertThrows("Named entity 'customer' is not a primary entity.", function(){
+    InvoiceWithCustomer.query("customer.month", 1);
+  });  
+};
diff --git a/test/moveToAngularCom/EntityDeclarationTest.js b/test/moveToAngularCom/EntityDeclarationTest.js
new file mode 100644
index 00000000..28986ea8
--- /dev/null
+++ b/test/moveToAngularCom/EntityDeclarationTest.js
@@ -0,0 +1,50 @@
+EntityDeclarationTest = TestCase('EntityDeclarationTest');
+
+EntityDeclarationTest.prototype.testEntityTypeOnly = function(){
+  expectAsserts(2);
+  var datastore = {entity:function(name){
+    assertEquals("Person", name);
+  }};
+  var scope = new Scope();
+  var init = scope.entity("Person", datastore);
+  assertEquals("", init);
+};
+
+EntityDeclarationTest.prototype.testWithDefaults = function(){
+  expectAsserts(4);
+  var datastore = {entity:function(name, init){
+    assertEquals("Person", name);
+    assertEquals("=a:", init.a);
+    assertEquals(0, init.b.length);
+  }};
+  var scope = new Scope();
+  var init = scope.entity('Person:{a:"=a:", b:[]}', datastore);
+  assertEquals("", init);
+};
+
+EntityDeclarationTest.prototype.testWithName = function(){
+  expectAsserts(2);
+  var datastore = {entity:function(name, init){
+    assertEquals("Person", name);
+    return function (){ return {}; };
+  }};
+  var scope = new Scope();
+  var init = scope.entity('friend=Person', datastore);
+  assertEquals("$anchor.friend:{friend=Person.load($anchor.friend);friend.$$anchor=\"friend\";};", init);
+};
+
+EntityDeclarationTest.prototype.testMultipleEntities = function(){
+  expectAsserts(3);
+  var expect = ['Person', 'Book'];
+  var i=0;
+  var datastore = {entity:function(name, init){
+    assertEquals(expect[i], name);
+    i++;
+    return function (){ return {}; };
+  }};
+  var scope = new Scope();
+  var init = scope.entity('friend=Person;book=Book;', datastore);
+  assertEquals("$anchor.friend:{friend=Person.load($anchor.friend);friend.$$anchor=\"friend\";};" +
+               "$anchor.book:{book=Book.load($anchor.book);book.$$anchor=\"book\";};",
+               init);
+};
diff --git a/test/moveToAngularCom/ModelTest.js b/test/moveToAngularCom/ModelTest.js
new file mode 100644
index 00000000..dbd97778
--- /dev/null
+++ b/test/moveToAngularCom/ModelTest.js
@@ -0,0 +1,84 @@
+ModelTest = TestCase('ModelTest');
+
+ModelTest.prototype.testLoadSaveOperations = function(){
+  var m1 = new DataStore().entity('A')();
+  m1.a = 1;
+
+  var m2 =  {b:1};
+
+  m1.$loadFrom(m2);
+
+  assertTrue(!m1.a);
+  assertEquals(m1.b, 1);
+};
+
+ModelTest.prototype.testLoadfromDoesNotClobberFunctions = function(){
+  var m1 = new DataStore().entity('A')();
+  m1.id = function(){return 'OK';};
+  m1.$loadFrom({id:null});
+  assertEquals(m1.id(), 'OK');
+
+  m1.b = 'OK';
+  m1.$loadFrom({b:function(){}});
+  assertEquals(m1.b, 'OK');
+};
+
+ModelTest.prototype.testDataStoreDoesNotGetClobbered = function(){
+  var ds = new DataStore();
+  var m = ds.entity('A')();
+  assertTrue(m.$$entity.datastore === ds);
+  m.$loadFrom({});
+  assertTrue(m.$$entity.datastore === ds);
+};
+
+ModelTest.prototype.testManagedModelDelegatesMethodsToDataStore = function(){
+  expectAsserts(7);
+  var datastore = new DataStore();
+  var model = datastore.entity("A", {a:1})();
+  var fn = {};
+  datastore.save = function(instance, callback) {
+    assertTrue(model === instance);
+    assertTrue(callback === fn);
+  };
+  datastore.remove = function(instance, callback) {
+    assertTrue(model === instance);
+    assertTrue(callback === fn);
+  };
+  datastore.load = function(instance, id, callback) {
+    assertTrue(model === instance);
+    assertTrue(id === "123");
+    assertTrue(callback === fn);
+  };
+  model.$save(fn);
+  model.$delete(fn);
+  model.$loadById("123", fn);
+};
+
+ModelTest.prototype.testManagedModelCanBeForcedToFlush = function(){
+  expectAsserts(6);
+  var datastore = new DataStore();
+  var model = datastore.entity("A", {a:1})();
+
+  datastore.save = function(instance, callback) {
+    assertTrue(model === instance);
+    assertTrue(callback === undefined);
+  };
+  datastore.remove = function(instance, callback) {
+    assertTrue(model === instance);
+    assertTrue(callback === undefined);
+  };
+  datastore.flush = function(){
+    assertTrue(true);
+  };
+  model.$save(true);
+  model.$delete(true);
+};
+
+
+ModelTest.prototype.testItShouldMakeDeepCopyOfInitialValues = function (){
+  var initial = {a:[]};
+  var entity = new DataStore().entity("A", initial);
+  var model = entity();
+  model.a.push(1);
+  assertEquals(0, entity().a.length);
+};
diff --git a/test/moveToAngularCom/ServerTest.js b/test/moveToAngularCom/ServerTest.js
new file mode 100644
index 00000000..02fab84c
--- /dev/null
+++ b/test/moveToAngularCom/ServerTest.js
@@ -0,0 +1,42 @@
+ServerTest = TestCase("ServerTest");
+ServerTest.prototype.testBreakLargeRequestIntoPackets = function() {
+  var log = "";
+  var server = new Server("http://server", function(url){
+    log += "|" + url;
+  });
+  server.maxSize = 30;
+  server.uuid = "uuid";
+  server.request("POST", "/data/database", {}, function(code, r){
+    assertEquals(200, code);
+    assertEquals("response", r);
+  });
+  angularCallbacks.uuid0("response");
+  assertEquals(
+      "|http://server/$/uuid0/2/1?h=eyJtIjoiUE9TVCIsInAiOnt9LCJ1Ij" +
+      "|http://server/$/uuid0/2/2?h=oiL2RhdGEvZGF0YWJhc2UifQ==",
+      log);
+};
+
+ServerTest.prototype.testItShouldEncodeUsingUrlRules = function() {
+  var server = new Server("http://server");
+  assertEquals("fn5-fn5-", server.base64url("~~~~~~"));
+  assertEquals("fn5_fn5_", server.base64url("~~\u007f~~\u007f"));
+};
+
+FrameServerTest = TestCase("FrameServerTest");
+
+FrameServerTest.prototype = {
+  testRead:function(){
+    var window = {name:'$DATASET:"MyData"'};
+    var server = new FrameServer(window);
+    server.read();
+    assertEquals("MyData", server.data);
+  },
+  testWrite:function(){
+    var window = {};
+    var server = new FrameServer(window);
+    server.data = "TestData";
+    server.write();
+    assertEquals('$DATASET:"TestData"', window.name);
+  }
+};
diff --git a/test/moveToAngularCom/UsersTest.js b/test/moveToAngularCom/UsersTest.js
new file mode 100644
index 00000000..f0ff545a
--- /dev/null
+++ b/test/moveToAngularCom/UsersTest.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2008,2009 BRAT Tech LLC
+
+UsersTest = TestCase("UsersTest");
+
+UsersTest.prototype = {
+  setUp:function(){},
+  
+  tearDown:function(){},
+  
+  testItShouldFetchCurrentUser:function(){
+    expectAsserts(5);
+    var user;
+    var users = new Users({request:function(method, url, request, callback){
+      assertEquals("GET", method);
+      assertEquals("/account.json", url);
+      assertEquals("{}", toJson(request));
+      callback(200, {$status_code:200, user:{name:'misko'}});
+    }});
+    users.fetchCurrentUser(function(u){
+      user = u;
+      assertEquals("misko", u.name);
+      assertEquals("misko", users.current.name);
+    });
+  }
+  
+};