entangled 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ea4626c7d1bb040d403f4da6b8b64021c81a29f
-  data.tar.gz: 639932af1572cfd2006295af882d23519e0c1f00
+  metadata.gz: da1eee63cbd14ff868400bd98f77d164b7625df0
+  data.tar.gz: 97a8f2215ebd469f203ad179d61f8beb9872aa63
 SHA512:
-  metadata.gz: 034e96b2cb4f1748c4ef748448974e1b54fd2fcaa7db7ff469eae55d45365ec5cee0da26daaacae459b2d903bc698b1e610547bfd56d52e61e2ba904acfdf196
-  data.tar.gz: 55d59ceeeddb3277e3d971db4926b10270e0e591062ce738b4dc2b9f7db8fc39bba89cf56b257bde97ff0542f342e59f353d793b192e5ff4f5a8bd11b45028ed
+  metadata.gz: 69972bd90800fdbd7bf64c96a27b25eca95b633971116351c604d0049ec164a9c5d4696d5a9278f990ee7b5fccf47ff804d2f325aefd88272f2798cd3e863c58
+  data.tar.gz: 8cf42b1b3bf5f5a6bbc1009d87c4e657c429cd7392ea1acb7895f411fbb422c05f04de7e1998332358c99594b8bcd2b4f4d60e2c759f6f3b11a2af864ea7c69b

data/README.md

@@ -268,6 +268,13 @@ Pick if you want to use Entangled with plain JavaScript or with Angular:
 - [entangled-js](https://github.com/dchacke/entangled-js)
 - [entangled-angular](https://github.com/dchacke/entangled-angular)
 
+The following versions are compatible:
+
+| entangled.gem | entangled-js.js | entangled-angular.js |
+|---------------|-----------------|----------------------|
+| 1.4.1         | 1.3.1           | 1.3.1                |
+| 1.4.1         | 1.3.0           | 1.3.0                |
+
 ## A Note On Cases
 The case conventions differ in Ruby and JavaScript. `snake_case` is the standard in Ruby, whereas `camelCase` is the standard in JavaScript.
 
@@ -281,22 +288,33 @@ This gem is best used for Rails apps that serve as APIs only and are not concern
 ## Limitations
 The gem relies heavily on convention over configuration and currently only works with restful style controllers as shown above. More features will be available soon. See the list of development priorities below.
 
+## Debugging Websockets
+To debug websockets from your terminal, you can use curl. For example, to do a handshake with a socket at `/messages` (a route you need to have set up), you can do the following:
+
+```shell
+curl -i -N -H "Connection: Upgrade" -H "Upgrade: websocket" -H "Host: echo.websocket.org" -H "Origin: http://localhost:3000" http://localhost:3000/messages
+```
+
+More information [here](http://www.thenerdary.net/post/24889968081/debugging-websockets-with-curl).
+
 ## Development Priorities
 The following features are to be implemented next:
 
-- Make broadcast method non-blocking using [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby); update Readme and repo description accordingly
-- Add compatibility table for Ruby/Angular/JS versions
+- Throw error if parent id not set on child when trying to fetch parent
+- Support multiple `hasMany` and `belongsTo` associations in front end
+- Put up example application (the todo list?)
 - Make prefix of create path `create_message` instead of `create_messages`
-- Support `belongsTo` in front end
 - Support `has_one` association in back end and front end and route helper for single resource
-- Add offline capabilities
+- Support scoping in back end
+- Add support for scopes and where clauses in front end once back end can do scopes à la [Spyke](https://github.com/balvig/spyke)
+- Display results of interactions to client immediately without going through the server; add server interactions to queue and constantly dequeue; if result from server conflicts with client state, update client accordingly
+- Add offline capabilities, i.e. only dequeue server interactions once internet connection established
 - Add authentication - with JWT?
 - On Heroku, tasks are always in different order depending on which ones are checked off and not
 - Add `$onChange` function to objects - or could a simple $watch and $watchCollection suffice?
 - Add diagram on how it works to Readme
 - GNU instead of MIT? Or something else? How to switch?
 - Contact Jessy to tweet about it!
-- Handle errors gracefully (e.g. finding a non-existent id, etc, authorization error in the back end, timeouts, etc)
 - Test controllers (see https://github.com/ngauthier/tubesock/issues/41)
 - Add `.destroyAll()` function to `Resources`
 

data/lib/entangled/controller.rb

@@ -61,165 +61,170 @@ module Entangled
       def broadcast(&block)
         # Use hijack to handle sockets
         hijack do |tubesock|
-          # Assuming restful controllers, the behavior of
-          # this method has to change depending on the action
-          # it's being used in
-          case action_name
-
-          # If the controller action is 'index', a collection
-          # of records should be broadcast
-          when 'index'
-            yield
-
-            # The following code will run if an instance
-            # variable with the plural resource name has been
-            # assigned in yield. For example, if a
-            # TacosController's index action looked something
-            # like this:
-
-            # def index
-            #   broadcast do
-            #     @tacos = Taco.all
-            #   end
-            # end
-
-            # ...then @tacos will be broadcast to all connected
-            # clients. The variable name, in this example,
-            # has to be "@tacos"
-            if collection
-              redis_thread = Thread.new do
-                redis.subscribe channel do |on|
-                  # Broadcast messages to all connected clients
-                  on.message do |channel, message|
-                    tubesock.send_data message
+          begin
+            # Assuming restful controllers, the behavior of
+            # this method has to change depending on the action
+            # it's being used in
+            case action_name
+
+            # If the controller action is 'index', a collection
+            # of records should be broadcast
+            when 'index'
+              execute_action(tubesock, block)
+
+              # The following code will run if an instance
+              # variable with the plural resource name has been
+              # assigned in yield. For example, if a
+              # TacosController's index action looked something
+              # like this:
+
+              # def index
+              #   broadcast do
+              #     @tacos = Taco.all
+              #   end
+              # end
+
+              # ...then @tacos will be broadcast to all connected
+              # clients. The variable name, in this example,
+              # has to be "@tacos"
+              if collection
+                redis_thread = Thread.new do
+                  redis.subscribe channel do |on|
+                    # Broadcast messages to all connected clients
+                    on.message do |channel, message|
+                      tubesock.send_data message
+                    end
+
+                    # Send message to whoever just subscribed
+                    tubesock.send_data({
+                      resources: collection
+                    }.to_json)
+
+                    close_db_connection
                   end
+                end
 
-                  # Send message to whoever just subscribed
-                  tubesock.send_data({
-                    resources: collection
-                  }.to_json)
-
-                  close_db_connection
+                # When client disconnects, kill the thread
+                tubesock.onclose do
+                  redis_thread.kill
                 end
               end
 
-              # When client disconnects, kill the thread
-              tubesock.onclose do
-                redis_thread.kill
-              end
-            end
+            # If the controller's action name is 'show', a single record
+            # should be broadcast
+            when 'show'
+              execute_action(tubesock, block)
+
+              # The following code will run if an instance variable
+              # with the singular resource name has been assigned in
+              # yield. For example, if a TacosController's show action
+              # looked something like this:
+
+              # def show
+              #   broadcast do
+              #     @taco = Taco.find(params[:id])
+              #   end
+              # end
 
-          # If the controller's action name is 'show', a single record
-          # should be broadcast
-          when 'show'
-            yield
-
-            # The following code will run if an instance variable
-            # with the singular resource name has been assigned in
-            # yield. For example, if a TacosController's show action
-            # looked something like this:
-
-            # def show
-            #   broadcast do
-            #     @taco = Taco.find(params[:id])
-            #   end
-            # end
-
-            # ...then @taco will be broadcast to all connected clients.
-            # The variable name, in this example, has to be "@taco"
-            if member
-              redis_thread = Thread.new do
-                redis.subscribe channel do |on|
-                  # Broadcast messages to all connected clients
-                  on.message do |channel, message|
-                    tubesock.send_data message
+              # ...then @taco will be broadcast to all connected clients.
+              # The variable name, in this example, has to be "@taco"
+              if member
+                redis_thread = Thread.new do
+                  redis.subscribe channel do |on|
+                    # Broadcast messages to all connected clients
+                    on.message do |channel, message|
+                      tubesock.send_data message
+                    end
+
+                    # Send message to whoever just subscribed
+                    tubesock.send_data({
+                      resource: member
+                    }.to_json)
+
+                    close_db_connection
                   end
+                end
 
-                  # Send message to whoever just subscribed
+                # When client disconnects, kill the thread
+                tubesock.onclose do
+                  redis_thread.kill
+                end
+              end
+
+            # If the controller's action name is 'create', a record should be
+            # created. Before yielding, the params hash has to be prepared
+            # with attributes sent to the socket. The actual publishing
+            # happens in the model's callback
+            when 'create'
+              tubesock.onmessage do |m|
+                set_resource_params(m)
+                execute_action(tubesock, block)
+
+                # Send resource that was just created back to client. The resource
+                # on the client will be overridden with this one. This is important
+                # so that the id, created_at and updated_at and possibly other
+                # attributes arrive on the client
+                if member
                   tubesock.send_data({
                     resource: member
                   }.to_json)
-
-                  close_db_connection
                 end
-              end
 
-              # When client disconnects, kill the thread
-              tubesock.onclose do
-                redis_thread.kill
-              end
-            end
-
-          # If the controller's action name is 'create', a record should be
-          # created. Before yielding, the params hash has to be prepared
-          # with attributes sent to the socket. The actual publishing
-          # happens in the model's callback
-          when 'create'
-            tubesock.onmessage do |m|
-              set_resource_params(m)
-              yield
-
-              # Send resource that was just created back to client. The resource
-              # on the client will be overridden with this one. This is important
-              # so that the id, created_at and updated_at and possibly other
-              # attributes arrive on the client
-              if member
-                tubesock.send_data({
-                  resource: member
-                }.to_json)
+                close_db_connection
               end
 
-              close_db_connection
-            end
+            # If the controller's action name is 'update', a record should be
+            # updated. Before yielding, the params hash has to be prepared
+            # with attributes sent to the socket
+            when 'update'
+              tubesock.onmessage do |m|
+                set_resource_params(m)
+                execute_action(tubesock, block)
+
+                # Send resource that was just updated back to client. The resource
+                # on the client will be overridden with this one. This is important
+                # so that the new updated_at and possibly other attributes arrive
+                # on the client
+                if member
+                  tubesock.send_data({
+                    resource: member
+                  }.to_json)
+                end
 
-          # If the controller's action name is 'update', a record should be
-          # updated. Before yielding, the params hash has to be prepared
-          # with attributes sent to the socket
-          when 'update'
-            tubesock.onmessage do |m|
-              set_resource_params(m)
-              yield
-
-              # Send resource that was just updated back to client. The resource
-              # on the client will be overridden with this one. This is important
-              # so that the new updated_at and possibly other attributes arrive
-              # on the client
-              if member
-                tubesock.send_data({
-                  resource: member
-                }.to_json)
+                close_db_connection
               end
 
-              close_db_connection
-            end
+            when 'destroy'
+              tubesock.onmessage do |m|
+                execute_action(tubesock, block)
 
-          when 'destroy'
-            tubesock.onmessage do |m|
-              yield
+                # Send resource that was just destroyed back to client
+                if member
+                  tubesock.send_data({
+                    resource: member
+                  }.to_json)
+                end
 
-              # Send resource that was just destroyed back to client
-              if member
-                tubesock.send_data({
-                  resource: member
-                }.to_json)
+                close_db_connection
               end
 
-              close_db_connection
-            end
-
-          # For every other controller action, simply wrap whatever is
-          # yielded in the tubesock block to execute it in the context
-          # of the socket. Other custom actions can be added through this
-          else
-            tubesock.onmessage do |m|
-              # If message was sent, attach to params (rescue exception if
-              # message not valid JSON or message not present)
-              params.merge!(JSON.parse(m)) rescue nil
+            # For every other controller action, simply wrap whatever is
+            # yielded in the tubesock block to execute it in the context
+            # of the socket. Other custom actions can be added through this
+            else
+              tubesock.onmessage do |m|
+                # If message was sent, attach to params (rescue exception if
+                # message not valid JSON or message not present)
+                params.merge!(JSON.parse(m)) rescue nil
 
-              yield
+                execute_action(tubesock, block)
 
-              close_db_connection
+                close_db_connection
+              end
             end
+          rescue Exception => e
+            Rails.logger.error e
+            close_db_connection
           end
         end
       end
@@ -227,6 +232,27 @@ module Entangled
       def set_resource_params(message_from_socket)
         params[resource_name.to_sym] = JSON.parse(message_from_socket)
       end
+
+      # Run the actual controller action that is passed as
+      # a block to the broadcast method and catch any exceptions
+      # as needed
+      def execute_action(tubesock, block)
+        begin
+          # Execute block
+          block.call
+        rescue Exception => e
+          # Log the error
+          Rails.logger.error e.message
+
+          # Print stack strace
+          puts e.backtrace
+
+          # Send error message to client
+          tubesock.send_data({
+            error: e.message
+          }.to_json)
+        end
+      end
     end
     
     def self.included(receiver)

data/lib/entangled/version.rb

@@ -1,3 +1,3 @@
 module Entangled
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/spec/dummy/public/app/controllers/list.js

@@ -3,10 +3,10 @@
 angular.module('entangledTest')
 
 .controller('ListCtrl', function($scope, $routeParams, List) {
-  List.find($routeParams.id, function(list) {
+  List.find($routeParams.id, function(err, list) {
     $scope.$apply(function() {
       $scope.list = list;
-      $scope.list.items().all(function(items) {
+      $scope.list.items().all(function(err, items) {
         $scope.$apply(function() {
           $scope.items = items;
         });

data/spec/dummy/public/app/controllers/lists.js

@@ -17,7 +17,7 @@ angular.module('entangledTest')
     list.$destroy();
   };
 
-  List.all(function(lists) {
+  List.all(function(err, lists) {
     $scope.$apply(function() {
       $scope.lists = lists;
     });

data/spec/dummy/public/app/entangled/entangled.js

@@ -7,10 +7,10 @@ angular.module('entangled', [])
     // Every response coming from the server will be wrapped
     // in a Resource constructor to represent a CRUD-able
     // resource that can be saved and destroyed using the
-    // methods $save(), $destroy, and others. A Resource also
+    // methods $save, $destroy, and others. A Resource also
     // stores the socket's URL it was retrieved from so it
     // can be reused for other requests.
-    function Resource(params, webSocketUrl, hasMany) {
+    function Resource(params, webSocketUrl, hasMany, belongsTo) {
       // Assign properties
       for (var key in params) {
         // Skip inherent object properties
@@ -20,14 +20,50 @@ angular.module('entangled', [])
       }
 
       // Assign socket URL
-      this.webSocketUrl = webSocketUrl;
+      this.socket = webSocketUrl;
+      this.webSocketUrl = function() {
+        // If a parent is associated, the websocket URL looks something
+        // like ws://localhost:3000/parents/:parentId/children. The
+        // following replaces :parentId with the actual parent's id
+        if (belongsTo) {
+          var parentIdPlaceholder = ':' + belongsTo + 'Id';
+          var parentId = this[belongsTo + 'Id'];
+          var newWebSocketUrl = this.socket.replace(parentIdPlaceholder, parentId);
+          return newWebSocketUrl;
+        } else {
+          // If no parent is associated, just return the plain URL
+          return this.socket;
+        }
+      };
 
-      // Assign has many relationship
+      // Assign parent relationship
       if (hasMany) {
         this[hasMany] = function() {
-          return new Entangled(this.webSocketUrl + '/' + this.id + '/' + hasMany);
+          return new Entangled(this.webSocketUrl() + '/' + this.id + '/' + hasMany);
         };
       }
+
+      // Assign child relationship
+      if (belongsTo) {
+        this[belongsTo] = function(callback) {
+          // Infer socket URL to parent from child's socket URL
+          var socketElements = this.webSocketUrl().split('/');
+          var parentSocket = socketElements.slice(socketElements.length - 6, 4).join('/');
+
+          // Instantiate new parent and get its id
+          var Parent = new Entangled(parentSocket);
+          var parentId = this[belongsTo + 'Id'];
+
+          // Find parent and pass it to callback
+          Parent.find(parentId, function(err, parent) {
+            if (err) {
+              callback(err)
+            } else {
+              callback(null, parent);
+            }
+          });
+        }.bind(this);
+      }
     };
 
     // $save() will send a request to the server
@@ -37,7 +73,7 @@ angular.module('entangled', [])
     Resource.prototype.$save = function(callback) {
       if (this.id) {
         // Update
-        var socket = new WebSocket(this.webSocketUrl + '/' + this.id + '/update');
+        var socket = new WebSocket(this.webSocketUrl() + '/' + this.id + '/update');
         socket.onopen = function() {
           socket.send(this.asSnakeJSON());
         }.bind(this);
@@ -47,6 +83,14 @@ angular.module('entangled', [])
           if (event.data) {
             var data = JSON.parse(event.data);
 
+            if (data.error) {
+              if (callback) {
+                callback(new Error(data.error));
+              }
+
+              return;
+            }
+
             // Assign/override new data (such as updated_at, etc)
             if (data.resource) {
               for (key in data.resource) {
@@ -57,17 +101,19 @@ angular.module('entangled', [])
 
           // Assign has many association. The association
           // can only be available to a persisted record
-          this[this.hasMany] = new Entangled(this.webSocketUrl + '/' + this.id + '/' + this.hasMany);
+          this[this.hasMany] = new Entangled(this.webSocketUrl() + '/' + this.id + '/' + this.hasMany);
 
           // Pass 'this' to callback for create
           // function so this the create function
           // can pass the created resource to its
           // own callback; not needed for $save per se
-          if (callback) callback(this);
+          if (callback) {
+            callback(null, this);
+          }
         }.bind(this);
       } else {
         // Create
-        var socket = new WebSocket(this.webSocketUrl + '/create');
+        var socket = new WebSocket(this.webSocketUrl() + '/create');
 
         // Send attributes to server
         socket.onopen = function() {
@@ -79,6 +125,14 @@ angular.module('entangled', [])
           if (event.data) {
             var data = JSON.parse(event.data);
 
+            if (data.error) {
+              if (callback) {
+                callback(new Error(data.error));
+              }
+
+              return;
+            }
+
             // Assign/override new data (such as id, created_at,
             // updated_at, etc)
             if (data.resource) {
@@ -92,7 +146,9 @@ angular.module('entangled', [])
           // function so this the create function
           // can pass the created resource to its
           // own callback; not needed for $save per se
-          if (callback) callback(this);
+          if (callback) {
+            callback(null, this)
+          };
         }.bind(this);
       }
     };
@@ -114,7 +170,8 @@ angular.module('entangled', [])
     // $destroy() will send a request to the server to
     // destroy an existing record.
     Resource.prototype.$destroy = function(callback) {
-      var socket = new WebSocket(this.webSocketUrl + '/' + this.id + '/destroy');
+      var socket = new WebSocket(this.webSocketUrl() + '/' + this.id + '/destroy');
+      // var socket = new WebSocket(this.webSocketUrl() + '/' + '2343345' + '/destroy');
 
       socket.onopen = function() {
         // It's fine to send an empty message since the
@@ -127,6 +184,14 @@ angular.module('entangled', [])
         if (event.data) {
           var data = JSON.parse(event.data);
 
+          if (data.error) {
+            if (callback) {
+              callback(new Error(data.error));
+            }
+
+            return;
+          }
+
           // Assign/override new data
           if (data.resource) {
             for (key in data.resource) {
@@ -142,7 +207,9 @@ angular.module('entangled', [])
           Object.freeze(this);
         }
 
-        if (callback) callback(this);
+        if (callback) {
+          callback(null, this);
+        }
       }.bind(this);
     };
 
@@ -223,16 +290,22 @@ angular.module('entangled', [])
       this.webSocketUrl = webSocketUrl;
     };
 
-    // hasMany() adds the appropriate association and
-    // sets up websockets accordingly
-    Entangled.prototype.hasMany = function(resources) {
-      this.hasMany = resources;
+    // hasMany() adds the appropriate parent association
+    // and sets up websockets accordingly
+    Entangled.prototype.hasMany = function(resourcesName) {
+      this.hasMany = resourcesName;
+    };
+
+    // belongsTo() adds the appropriate child association
+    // and sets up websockets accordingly
+    Entangled.prototype.belongsTo = function(resourceName) {
+      this.belongsTo = resourceName;
     };
 
     // Function to instantiate a new Resource, optionally
     // with given parameters
     Entangled.prototype.new = function(params) {
-      return new Resource(params, this.webSocketUrl, this.hasMany);
+      return new Resource(params, this.webSocketUrl, this.hasMany, this.belongsTo);
     };
 
     // Retrieve all Resources from the root of the socket's
@@ -246,6 +319,12 @@ angular.module('entangled', [])
           // Convert message to JSON
           var data = JSON.parse(event.data);
 
+          if (data.error) {
+            callback(new Error(data.error));
+
+            return;
+          }
+
           // If the collection of Resources was sent
           if (data.resources) {
             // Store retrieved Resources in property
@@ -288,7 +367,7 @@ angular.module('entangled', [])
 
         // Run the callback and pass in the
         // resulting collection
-        callback(this.resources.all);
+        callback(null, this.resources.all);
       }.bind(this);
     };
 
@@ -309,6 +388,12 @@ angular.module('entangled', [])
           // Parse message and convert to JSON
           var data = JSON.parse(event.data);
 
+          if (data.error) {
+            callback(new Error(data.error));
+
+            return;
+          }
+
           if (data.resource && !data.action) {
             // If the Resource was sent from the server,
             // store it
@@ -330,7 +415,7 @@ angular.module('entangled', [])
         }
 
         // Run callback with retrieved Resource
-        callback(this.resource);
+        callback(null, this.resource);
       }.bind(this);
     };
 

data/spec/dummy/public/test/services/entangled_test.js

@@ -5,7 +5,8 @@ describe('Entangled', function() {
 
   var $injector,
   Entangled,
-  List;
+  List,
+  Item;
 
   beforeEach(inject(function() {
     $injector = angular.injector(['entangled']);
@@ -13,6 +14,9 @@ describe('Entangled', function() {
 
     List = new Entangled('ws://localhost:3000/lists');
     List.hasMany('items');
+
+    Item = new Entangled('ws://localhost:3000/lists/:listId/items');
+    Item.belongsTo('list');
   }));
 
   describe('constructor', function() {
@@ -31,8 +35,13 @@ describe('Entangled', function() {
 
   describe('.all', function() {
     it('fetches all lists', function(done) {
-      List.all(function(lists) {
+      List.all(function(err, lists) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Assert that lists are set
         expect(lists).toEqual(jasmine.any(Array));
+
         done();
       });
     });
@@ -40,9 +49,14 @@ describe('Entangled', function() {
 
   describe('.create', function() {
     it('creates a list', function(done) {
-      List.create({ name: 'foo' }, function(list) {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Assert that list was created successfully
         expect(list.id).toBeDefined();
         expect(list.createdAt).toBeDefined();
+
         done();
       });
     });
@@ -50,8 +64,13 @@ describe('Entangled', function() {
     it('receives validation messages', function(done) {
       // Leave out name, causing model validations
       // in ActiveRecord to fail
-      List.create({}, function(list) {
+      List.create({}, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Assert that validation errors are attached
         expect(list.errors.name.indexOf("can't be blank") > -1).toBeTruthy();
+
         done();
       });
     });
@@ -59,14 +78,35 @@ describe('Entangled', function() {
 
   describe('.find', function() {
     it('finds a list', function(done) {
-      List.create({ name: 'foo' }, function(list) {
-        List.find(list.id, function(list) {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        List.find(list.id, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Assert that list was found
           expect(list.id).toBeDefined();
           expect(list.createdAt).toBeDefined();
+
           done();
         });
       });
     });
+
+    it('receives an error when looking for a list that does not exist', function(done) {
+      List.find('not an id', function(err, list) {
+        // Assert that error is set
+        expect(err).toEqual(jasmine.any(Error));
+        expect(err.message).toEqual("Couldn't find List with 'id'=not an id");
+
+        // Assert that no second parameter was passed to callback
+        expect(list).not.toBeDefined();
+
+        done();
+      })
+    });
   });
 
   describe('#$save', function() {
@@ -74,9 +114,14 @@ describe('Entangled', function() {
       it('saves a new list', function(done) {
         var list = List.new({ name: 'foo' });
 
-        list.$save(function() {
+        list.$save(function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Assert that list was persisted
           expect(list.id).toBeDefined();
           expect(list.createdAt).toBeDefined();
+
           done();
         });
       });
@@ -86,8 +131,13 @@ describe('Entangled', function() {
         // in ActiveRecord to fail
         var list = List.new();
 
-        list.$save(function() {
+        list.$save(function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Assert that validation errors are attached
           expect(list.errors.name.indexOf("can't be blank") > -1).toBeTruthy();
+
           done();
         });
       });
@@ -95,31 +145,72 @@ describe('Entangled', function() {
 
     describe('existing record', function() {
       it('updates an existing list', function(done) {
-        List.create({ name: 'foo' }, function(list) {
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Prepare for update
           list.name = 'new name';
+
+          // Remember old updatedAt to compare once saved
           var oldUpdatedAt = list.updatedAt;
 
-          list.$save(function() {
+          // Save
+          list.$save(function(err, list) {
+            // Assert that err is null
+            expect(err).toEqual(null);
+
+            // Assert that list was updated successfully
             expect(list.name).toBe('new name');
             expect(list.updatedAt).not.toEqual(oldUpdatedAt);
+
             done();
           });
         });
       });
 
       it('receives validation messages', function(done) {
-        List.create({ name: 'foo' }, function(list) {
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
           // Make invalid by setting the name to an
           // empty string, causing model validations
           // in ActiveRecord to fail
           list.name = '';
           var oldUpdatedAt = list.updatedAt;
 
-          list.$save(function() {
+          list.$save(function(err, list) {
+            // Assert that err is null
+            expect(err).toEqual(null);
+
             // Assert that the list was not updated
             // by the server
             expect(list.updatedAt).toBe(oldUpdatedAt);
             expect(list.errors.name.indexOf("can't be blank") > -1).toBeTruthy();
+
+            done();
+          });
+        });
+      });
+
+      it('receives an error when trying to save a record without being able to find it', function(done) {
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Prepare for update
+          list.id = 'not an id';
+
+          // Save
+          list.$save(function(err, list) {
+            // Assert that error is set
+            expect(err).toEqual(jasmine.any(Error));
+            expect(err.message).toEqual("Couldn't find List with 'id'=not an id");
+
+            // Assert that no second parameter was passed to callback
+            expect(list).not.toBeDefined();
+
             done();
           });
         });
@@ -129,29 +220,69 @@ describe('Entangled', function() {
 
   describe('#$update', function() {
     it('updates a list in place', function(done) {
-      List.create({ name: 'foo' }, function(list) {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Remember old updatedAt to compare once updated
         var oldUpdatedAt = list.updatedAt;
 
-        list.$update({ name: 'new name' }, function() {
+        // Update
+        list.$update({ name: 'new name' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Assert that list was updated successfully
           expect(list.name).toBe('new name');
           expect(list.updatedAt).not.toEqual(oldUpdatedAt);
+
           done();
         });
       });
     });
 
     it('receives validation messages', function(done) {
-      List.create({ name: 'foo' }, function(list) {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Remember old updatedAt to compare once updated
         var oldUpdatedAt = list.updatedAt;
 
         // Make invalid by setting the name to an
         // empty string, causing model validations
         // in ActiveRecord to fail
-        list.$update({ name: '' }, function() {
+        list.$update({ name: '' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
           // Assert that the list was not updated
           // by the server
           expect(list.updatedAt).toBe(oldUpdatedAt);
           expect(list.errors.name.indexOf("can't be blank") > -1).toBeTruthy();
+
+          done();
+        });
+      });
+    });
+
+    it('receives an error when trying to save a record without being able to find it', function(done) {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        // Prepare for update
+        // list.id = 'not an id';
+
+        // Save
+        list.$update({ id: 'not an id' }, function(err, list) {
+          // Assert that error is set
+          expect(err).toEqual(jasmine.any(Error));
+          expect(err.message).toEqual("Couldn't find List with 'id'=not an id");
+
+          // Assert that no second parameter was passed to callback
+          expect(list).not.toBeDefined();
+
           done();
         });
       });
@@ -160,13 +291,25 @@ describe('Entangled', function() {
 
   describe('#$destroy', function() {
     it('destroys a list', function(done) {
-      List.create({ name: 'foo' }, function(list) {
-        list.$destroy(function() {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        list.$destroy(function(err, list) {
+          // Assert that no error happened
+          expect(err).toEqual(null);
+
           // If successfully destroyed, it won't be
           // included in the collection of all records
           // anymore
-          List.all(function(lists) {
+          List.all(function(err, lists) {
+            // Assert that no error happened
+            expect(err).toEqual(null);
+
+            // Assert that list not included in lists
+            // anymore
             expect(lists.indexOf(list)).toBe(-1);
+
             done();
           });
         });
@@ -174,22 +317,59 @@ describe('Entangled', function() {
     });
 
     it('marks the record as destroyed', function(done) {
-      List.create({ name: 'foo' }, function(list) {
-        list.$destroy(function() {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        list.$destroy(function(err, list) {
+          // Assert that no error happened
+          expect(err).toEqual(null);
+
+          // Asser that list is destroyed
           expect(list.destroyed).toBeTruthy();
+
           done();
         });
       });
     });
 
     it('freezes the record', function(done) {
-      List.create({ name: 'foo' }, function(list) {
-        list.$destroy(function() {
+      List.create({ name: 'foo' }, function(err, list) {
+        // Assert that err is null
+        expect(err).toEqual(null);
+
+        list.$destroy(function(err, list) {
+          // Assert that no error happened
+          expect(err).toEqual(null);
+
+          // Assert that list is frozen
           expect(Object.isFrozen(list)).toBeTruthy();
+
           done();
         });
       });
     });
+
+    it('has an error when an exception happens in the back end', function(done) {
+      // Try to destroy list that's not in the database,
+      // thereby triggering an exception in the back end,
+      // which should trigger an exception in the front end
+      var list = List.new({ id: 1234 });
+
+      list.$destroy(function(err, noList) {
+        // Assert that error is defined and has the right message
+        expect(err).toEqual(jasmine.any(Error));
+        expect(err.message).toEqual("Couldn't find List with 'id'=1234");
+
+        // Assert that list was not frozen
+        expect(Object.isFrozen(list)).not.toBeTruthy();
+
+        // Assert that no second parameter was sent to callback
+        expect(noList).not.toBeDefined();
+
+        done();
+      });
+    });
   });
 
   describe('#$valid', function() {
@@ -322,17 +502,89 @@ describe('Entangled', function() {
   });
 
   describe('Associations', function() {
-    it('has many items', function(done) {
-      List.create({ name: 'foo' }, function(list) {
-        // Assert that relationship defined
-        expect(list.items).toBeDefined();
-
-        // Assert that relationship is also
-        // an instance of Entangled, meaning
-        // in turn that all class and instance
-        // methods are available on it
-        expect(list.items().constructor.name).toBe('Entangled');
-        done();
+    describe('List', function() {
+      it('has many items', function(done) {
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Assert that relationship defined
+          expect(list.items).toBeDefined();
+
+          // Assert that relationship is also
+          // an instance of Entangled, meaning
+          // in turn that all class and instance
+          // methods are available on it
+          expect(list.items().constructor.name).toBe('Entangled');
+
+          done();
+        });
+      });
+    });
+
+    describe('Item', function() {
+      it('belongs to a list', function(done) {
+        // Create parent list
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Create child item
+          Item.create({ name: 'foo', listId: list.id }, function(err, item) {
+            // Assert that err is null
+            expect(err).toEqual(null);
+
+            // Assert that creation successful
+            expect(item.$persisted()).toBeTruthy();
+
+            // Assert parent relationship
+            // expect(item.list).toBe(list);
+            var originalList = list;
+
+            item.list(function(err, list) {
+              // Assert that err is null
+              expect(err).toEqual(null);
+
+              // Assert that the original list and the parent
+              // are the same
+              expect(originalList.id).toBe(list.id);
+
+              done();
+            });
+          });
+        });
+      });
+
+      it('receives an error when trying to find a parent that does not exist', function(done) {
+        // Create parent list
+        List.create({ name: 'foo' }, function(err, list) {
+          // Assert that err is null
+          expect(err).toEqual(null);
+
+          // Create child item
+          Item.create({ name: 'foo', listId: list.id }, function(err, item) {
+            // Assert that err is null
+            expect(err).toEqual(null);
+
+            // Assert that creation successful
+            expect(item.$persisted()).toBeTruthy();
+
+            // Change parent id to a non-existent id
+            item.listId = 'not an id';
+
+            item.list(function(err, list) {
+              // Assert that err is set
+              expect(err).toEqual(jasmine.any(Error));
+              expect(err.message).toEqual("Couldn't find List with 'id'=not an id");
+
+              // Assert that no second parameter was passed
+              // to the callback
+              expect(list).not.toBeDefined();
+
+              done();
+            });
+          });
+        });
       });
     });
   });

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: entangled
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Dennis Charles Hackethal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-13 00:00:00.000000000 Z
+date: 2015-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler