todo_rails 0.1.1 → 0.1.2

data/vendor/assets/bower_components/restangular/test/restangularSpec.js

@@ -0,0 +1,1136 @@
+describe("Restangular", function() {
+  // API
+  var Restangular, $httpBackend;
+  var accountsModel, restangularAccounts, restangularAccount0, restangularAccount1;
+  var accountsHalModel;
+  var messages, newAccount;
+
+  // Load required modules
+  beforeEach(angular.mock.module("restangular"));
+
+  // Init HTTP mock backend and Restangular resources
+  beforeEach(inject(function($injector) {
+    // Model
+    accountsModel = [
+      {id: 0, user: "Martin ", amount: 42, transactions: []},
+      {id: 1, user: "Paul", amount: 3.1416, transactions: [{from: "Martin", amount: 3, id: 0}, {from: "Anonymous", amount: 0.1416, id:1}]}
+    ];
+
+    // HAL model (http://stateless.co/hal_specification.html)
+    accountsHalModel = [
+      {id: 0, user: "Martin", amount: 42, transaction: [], _links: {self: "/accountsHAL/martin"}},
+      {id: 1, user: "Paul", amount: 3.1416, transaction: [
+        {from: "Martin", amount: 3, id: 0, _links: {self: "/accountsHAL/paul/transactions/0"}},
+        {from: "Anonymous", amount: 0.1416, id: 1, _links: {self: "/accountsHAL/paul/transactions/1"}}
+      ], _links: {self: "/accountsHAL/paul"}}
+    ];
+
+    infoModel = {
+      id: 0, text: "Some additional account information"
+    }
+
+    newAccount = {id: 44, user: "First User", amount: 45, transactions: []};
+
+    messages = [{id: 23, name: "Gonto"}, {id: 45, name: "John"}]
+
+    accountsDoSomethingModel = { result: 1 };
+
+    $httpBackend = $injector.get("$httpBackend");
+
+    $httpBackend.when("HEAD", "/accounts").respond();
+    $httpBackend.when("TRACE", "/accounts").respond();
+    $httpBackend.when("OPTIONS", "/accounts").respond();
+
+    $httpBackend.whenGET("/accounts").respond(accountsModel);
+    $httpBackend.whenGET("/accounts/do-something").respond(accountsDoSomethingModel);
+    $httpBackend.whenJSONP("/accounts").respond(accountsModel);
+    $httpBackend.whenGET("/accounts/0,1").respond(accountsModel);
+    $httpBackend.whenGET("/accounts/messages").respond(messages);
+    $httpBackend.whenGET("/accounts/1/message").respond(messages[0]);
+    $httpBackend.whenGET("/accounts/1/messages").respond(messages);
+    $httpBackend.whenGET("/accounts/0").respond(accountsModel[0]);
+    $httpBackend.whenGET("/accounts/1").respond(accountsModel[1]);
+    $httpBackend.whenJSONP("/accounts/1").respond(accountsModel[1]);
+    $httpBackend.whenGET("/accounts/1/transactions").respond(accountsModel[1].transactions);
+    $httpBackend.whenGET("/accounts/1/transactions/1").respond(accountsModel[1].transactions[1]);
+
+    $httpBackend.whenGET("/info").respond(infoModel);
+    $httpBackend.whenGET("/accounts/1/info").respond(infoModel);
+    $httpBackend.whenPUT("/info").respond(function(method, url, data) {
+      return [200, data, ""];
+    });
+
+    $httpBackend.whenGET("/accountsHAL").respond(accountsHalModel);
+    $httpBackend.whenPUT("/accountsHAL/martin").respond(function(method, url, data) {
+      accountsHalModel[0] = angular.fromJson(data);
+      return [200, data, ""];
+    });
+
+    // Full URL
+    $httpBackend.whenGET('http://accounts.com/all').respond(accountsModel);
+
+    $httpBackend.whenPOST("/accounts").respond(function(method, url, data, headers) {
+      var newData = angular.fromJson(data);
+      newData.fromServer = true;
+      return [201, JSON.stringify(newData), ""];
+    });
+
+    $httpBackend.whenPOST("/accounts/1/transactions").respond(function(method, url, data, headers) {
+      return [201, "", ""];
+    });
+
+    $httpBackend.whenDELETE("/accounts/1/transactions/1").respond(function(method, url, data, headers) {
+      return [200, "", ""];
+    });
+
+    $httpBackend.whenDELETE("/accounts/1").respond(function(method, url, data, headers) {
+      return [200, "", ""];
+    });
+
+    $httpBackend.whenPOST("/accounts/1").respond(function(method, url, data, headers) {
+      return [200, "", ""];
+    });
+
+    $httpBackend.whenPUT("/accounts/1").respond(function(method, url, data, headers) {
+      accountsModel[1] = angular.fromJson(data);
+      return [201, data, ""];
+    });
+
+    $httpBackend.whenGET("/error").respond(function() {
+      return [500, {}, ""];
+    });
+
+    $httpBackend.whenPOST("/customs").respond(function(method, url, data, headers) {
+      if (JSON.parse(data).one) {
+        return [201, "", ""];
+      } else {
+        return [400, "", ""];
+      }
+    });
+
+    // return the status code given
+    // e.g.: /error/404 returns 404 Not Found
+    var urlRegex = /\/error\/(\d{3})/;
+    $httpBackend.whenGET(urlRegex).respond(function(method, url, data, headers) {
+      return [url.match(urlRegex)[1], {}, ""];
+    });
+
+    Restangular = $injector.get("Restangular");
+    restangularAccounts = Restangular.all("accounts");
+    restangularAccount0 = Restangular.one("accounts", 0);
+    restangularAccount1 = Restangular.one("accounts", 1);
+
+
+    // Another API for testing
+    customers = [
+      {
+        id: 0,
+        name: "Alice",
+        status: 'active',
+        credit: 4000.0
+      },
+      {
+        id: 1,
+        name: "Bob",
+        status: 'active',
+        credit: 4000.0
+      },
+      {
+        id: 2,
+        name: "Carl",
+        status: 'active',
+        credit: 4000.0
+      }
+    ];
+    publications = [
+      {
+        id: 1,
+        title: "Sample",
+        content: "Rich data",
+        tags: [
+          'science',
+          'chemistry'
+        ]
+      }
+    ];
+    newCustomer = {
+      id: 3,
+      name: "New",
+      status: 'active',
+      credit: 4000.0
+    };
+
+    $httpBackend.whenGET("/customers/").respond(customers);
+    $httpBackend.whenGET("http://localhost:8080/customers/").respond(customers);
+    $httpBackend.whenGET("api.new.domain/customers/").respond(customers);
+    $httpBackend.whenGET("/customers/?active=true").respond(customers);
+    $httpBackend.whenGET("/customers/publications/?tags=chemistry").respond(publications);
+    $httpBackend.whenPUT("/customers/0").respond(function (method, url, data) {
+      customers[0] = angular.fromJson(data);
+      return [200, data, ""];
+    });
+    $httpBackend.whenPOST("/customers/").respond(function (method, url, data, headers) {
+      var newData = angular.fromJson(data);
+      newData.fromServer = true;
+      return [201, JSON.stringify(newData), ""];
+    });
+
+  }));
+
+  afterEach(function() {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  describe("Interceptors", function() {
+    it("Should add multiple request and response interceptors", function() {
+      Restangular.addRequestInterceptor(function(elem) {
+        var elemCopy = angular.copy(elem);
+        elemCopy.firstRequestInterceptor = true;
+        return elemCopy;
+      });
+      Restangular.addRequestInterceptor(function(elem) {
+        expect(elem.firstRequestInterceptor).toBeDefined();
+        var elemCopy = angular.copy(elem);
+        elemCopy.secondRequestInterceptor = true;
+        return elemCopy;
+      });
+      Restangular.addFullRequestInterceptor(function(elem) {
+        expect(elem.firstRequestInterceptor).toBeDefined();
+        expect(elem.secondRequestInterceptor).toBeDefined();
+        var elemCopy = angular.copy(elem);
+        elemCopy.thirdRequestInterceptor = true;
+        return {
+          element: elemCopy
+        };
+      });
+
+      Restangular.addResponseInterceptor(function(elem) {
+        var elemCopy = angular.copy(elem);
+        elemCopy.firstResponseInterceptor = true;
+        return elemCopy;
+      });
+
+      Restangular.addResponseInterceptor(function(elem) {
+        expect(elem.firstResponseInterceptor).toBeDefined();
+        var elemCopy = angular.copy(elem);
+        elemCopy.secondResponseInterceptor = true;
+        return elemCopy;
+      });
+
+      $httpBackend.whenPOST("/list").respond(function(method, url, data, headers) {
+        var elem = angular.fromJson(data);
+        expect(elem.firstRequestInterceptor).toBeDefined();
+        expect(elem.secondRequestInterceptor).toBeDefined();
+        expect(elem.thirdRequestInterceptor).toBeDefined();
+        return [200, elem, ""];
+      });
+
+      $httpBackend.expectPOST('/list');
+
+       Restangular.all('list').post({name: "Gonto"}).then(function(elem) {
+        expect(elem.firstResponseInterceptor).toBeDefined();
+        expect(elem.secondResponseInterceptor).toBeDefined();
+       });
+
+       $httpBackend.flush();
+    });
+
+    it("Should add multiple error interceptors", function() {
+      $httpBackend.expectGET("/error");
+
+      var CallbackManager = function() {};
+      CallbackManager.successCallback = function() {
+        expect(CallbackManager.successCallback).not.toHaveBeenCalled();
+      };
+      CallbackManager.errorCallback = function() {
+        expect(CallbackManager.firstErrorInterceptor).toHaveBeenCalled();
+        expect(CallbackManager.secondErrorInterceptor).toHaveBeenCalled();
+      };
+
+      CallbackManager.firstErrorInterceptor = function() {};
+      CallbackManager.secondErrorInterceptor = function() {};
+
+      spyOn(CallbackManager, "successCallback").andCallThrough();
+      spyOn(CallbackManager, "firstErrorInterceptor").andCallThrough();
+      spyOn(CallbackManager, "secondErrorInterceptor").andCallThrough();
+
+      Restangular.addErrorInterceptor(CallbackManager.firstErrorInterceptor);
+      Restangular.addErrorInterceptor(CallbackManager.secondErrorInterceptor);
+
+      Restangular.all("error").getList()
+        .then(CallbackManager.successCallback)
+        .catch(CallbackManager.errorCallback);
+
+      $httpBackend.flush();
+    });
+
+    it("Should add multiple error interceptors but don't reject the promise if one of them returns false", function() {
+      $httpBackend.expectGET("/error");
+
+      var CallbackManager = function() {};
+      CallbackManager.successCallback = function() {
+        expect(CallbackManager.successCallback).not.toHaveBeenCalled();
+      };
+      CallbackManager.errorCallback = function() {
+        expect(CallbackManager.errorCallback).not.toHaveBeenCalled();
+      };
+
+      CallbackManager.firstErrorInterceptor = function() {
+        return true;
+      };
+      CallbackManager.secondErrorInterceptor = function() {
+        return false; // prevent promise to be rejected
+      };
+
+      spyOn(CallbackManager, "successCallback").andCallThrough();
+      spyOn(CallbackManager, "errorCallback").andCallThrough();
+
+      Restangular.addErrorInterceptor(CallbackManager.firstErrorInterceptor);
+      Restangular.addErrorInterceptor(CallbackManager.secondErrorInterceptor);
+
+      Restangular.all("error").getList()
+        .then(CallbackManager.successCallback)
+        .catch(CallbackManager.errorCallback);
+
+      $httpBackend.flush();
+    });
+
+    it("Should add multiple error interceptors for a single get too", function() {
+      $httpBackend.expectGET("/error/404");
+
+      var CallbackManager = function() {};
+      CallbackManager.successCallback = function() {
+        expect(CallbackManager.successCallback).not.toHaveBeenCalled();
+      };
+      CallbackManager.errorCallback = function() {
+        expect(CallbackManager.firstErrorInterceptor).toHaveBeenCalled();
+        expect(CallbackManager.secondErrorInterceptor).toHaveBeenCalled();
+      };
+
+      CallbackManager.firstErrorInterceptor = function(response) {
+        expect(response.status).toEqual(404);
+      };
+      CallbackManager.secondErrorInterceptor = function() {};
+
+      spyOn(CallbackManager, "successCallback").andCallThrough();
+      spyOn(CallbackManager, "firstErrorInterceptor").andCallThrough();
+      spyOn(CallbackManager, "secondErrorInterceptor").andCallThrough();
+
+      Restangular.addErrorInterceptor(CallbackManager.firstErrorInterceptor);
+      Restangular.addErrorInterceptor(CallbackManager.secondErrorInterceptor);
+
+      Restangular.one("error", 404).get()
+          .then(CallbackManager.successCallback)
+          .catch(CallbackManager.errorCallback);
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("Transformers", function() {
+    it("Should decorate element both on server and local by default", function() {
+
+      Restangular.extendModel('accounts', function(account) {
+        account.extended = function() {return true;}
+        return account;
+      });
+
+      Restangular.one('accounts', 1).get().then(function(account) {
+        expect(account.extended).toBeDefined();
+      });
+
+      var local = {};
+      Restangular.restangularizeElement(null, local, 'accounts');
+      expect(local.extended).toBeDefined();
+
+      $httpBackend.flush();
+    });
+
+  });
+
+  describe("With Suffix", function() {
+    it("shouldn't add suffix to getRestangularUrl", function() {
+      var suffixRestangular = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.setRequestSuffix('.json');
+      });
+      var collection = suffixRestangular.all('accounts');
+      expect(collection.getRestangularUrl()).toBe('/accounts');
+      expect(collection.one('1').getRestangularUrl()).toBe('/accounts/1');
+    });
+
+    it("should add suffix to getRequestedUrl", function() {
+      var suffixRestangular = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.setRequestSuffix('.json');
+      });
+      var collection = suffixRestangular.all('accounts');
+      expect(collection.getRequestedUrl()).toBe('/accounts.json');
+      expect(collection.one('1').getRequestedUrl()).toBe('/accounts/1.json');
+    });
+
+    it("should add suffix to request", function() {
+      var suffixRestangular = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.setRequestSuffix('.json');
+      });
+      var collection = suffixRestangular.all('accounts');
+      $httpBackend.expectGET('/accounts.json').respond(200);
+      $httpBackend.expectGET('/accounts/1.json').respond(200);
+      collection.getList();
+      collection.get('1');
+      $httpBackend.flush();
+    });
+
+    it("shouldn't add suffix to allUrl", function() {
+      var suffixRestangular = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.setRequestSuffix('.json');
+      });
+      $httpBackend.expectGET('http://accounts.com/all');
+      suffixRestangular.allUrl('accounts', 'http://accounts.com/all').getList();
+      $httpBackend.flush();
+    });
+  });
+
+  describe("JSONp", function() {
+    it("should work for get", function() {
+      Restangular.setJsonp(true);
+      Restangular.one('accounts', 1).get();
+
+      $httpBackend.expectJSONP('/accounts/1');
+      $httpBackend.flush();
+    });
+
+    it("should work for getList", function() {
+      Restangular.setJsonp(true);
+      Restangular.all('accounts').getList();
+
+      $httpBackend.expectJSONP('/accounts');
+      $httpBackend.flush();
+    });
+
+    it("shouldn't override post", function() {
+      Restangular.setJsonp(true);
+      restangularAccounts.post({id: 2, user: "Someone"});
+
+      $httpBackend.expectPOST('/accounts').respond(201, '');
+      $httpBackend.flush();
+    });
+
+
+  });
+
+  describe("Local data", function() {
+    it("Should restangularize a collection OK", function() {
+      var collection = angular.copy(accountsModel);
+
+      Restangular.restangularizeCollection(null, collection, 'accounts');
+
+      expect(_.has(collection, 'get')).toBe(true);
+      expect(_.has(collection[0], 'get')).toBe(true);
+
+      expect(collection.getRestangularUrl()).toBe('/accounts');
+      expect(collection[0].getRestangularUrl()).toBe('/accounts/0');
+
+    });
+  });
+
+  describe("restangularizePromiseIntercept", function() {
+    it("should be invoked by restangularizePromise", function() {
+      var calledWithPromise;
+
+      Restangular.setRestangularizePromiseInterceptor(function(promise) {
+        calledWithPromise = promise;
+
+        promise.$object.$custom = true;
+      });
+
+      var promise = Restangular.one('accounts', 1).get();
+
+      expect(calledWithPromise).toBeDefined();
+      expect(promise.$object.$custom).toBeDefined();
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("$object", function() {
+    it("Should work for single get", function() {
+      var promise = Restangular.one('accounts', 1).get();
+      var obj = promise.$object;
+      expect(obj).toBeDefined();
+      expect(obj.amount).toBeUndefined();
+
+      $httpBackend.flush();
+
+      expect(obj.amount).toEqual(3.1416);
+    });
+
+    it("Shouldn't be restangularized by default", function() {
+      Restangular.extendModel('accounts', function(account) {
+        account.extended = function() {return true;}
+        return account;
+      });
+
+      var promise = Restangular.one('accounts', 1).get();
+      var obj = promise.$object;
+      expect(obj).toBeDefined();
+      expect(obj.extended).toBeUndefined();
+
+      $httpBackend.flush();
+    });
+
+    it("Should work for single get", function() {
+      var promise = Restangular.all('accounts').getList();
+      var list = promise.$object;
+      expect(list).toBeDefined();
+      expect(list.length).toEqual(0);
+
+      $httpBackend.flush();
+
+      expect(list.length).toEqual(2);
+      expect(list[1].amount).toEqual(3.1416);
+    });
+  });
+
+  describe("ALL", function() {
+    it("getList() should return an array of items", function() {
+      restangularAccounts.getList().then(function(accounts) {
+        expect(Restangular.stripRestangular(accounts)).toEqual(Restangular.stripRestangular(accountsModel));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("several getList() should return an array of items", function() {
+      $httpBackend.expectGET('/accounts/0,1');
+      Restangular.several("accounts", 0, 1).getList().then(function(accounts) {
+        expect(Restangular.stripRestangular(accounts)).toEqual(Restangular.stripRestangular(accountsModel));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("several remove() should work", function() {
+      $httpBackend.expectDELETE('/accounts/0,1').respond([200, "", ""]);
+      Restangular.several("accounts", 0, 1).remove();
+
+      $httpBackend.flush();
+    });
+
+    it("get(id) should return the item with given id", function() {
+      restangularAccounts.get(0).then(function(account) {
+        expect(Restangular.stripRestangular(account)).toEqual(Restangular.stripRestangular(accountsModel[0]));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it('uses all to get the list without parameters', function() {
+      Restangular.one('accounts', 1).all('messages').getList();
+      $httpBackend.expectGET('/accounts/1/messages');
+      $httpBackend.flush();
+    });
+
+    it("Custom GET methods should work", function() {
+      restangularAccounts.customGETLIST("messages").then(function(msgs) {
+        expect(Restangular.stripRestangular(msgs)).toEqual(Restangular.stripRestangular(messages));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("post() should add a new item", function() {
+      restangularAccounts.post({id: 2, user: "Someone"}).then(function() {
+        expect(accountsModel.length).toEqual(2);
+      });
+
+      $httpBackend.expectPOST('/accounts').respond(201, '');
+      $httpBackend.flush();
+    });
+
+    it("customPOST() should add a new item", function() {
+      restangularAccounts.customPOST({id: 2, user: "Someone"}).then(function() {
+        expect(accountsModel.length).toEqual(2);
+      });
+
+      $httpBackend.expectPOST('/accounts').respond(201, '');
+      $httpBackend.flush();
+    });
+
+    it("post() should work with arrays", function() {
+     Restangular.all('places').post([{name: "Gonto"}, {name: 'John'}]).then(function(value) {
+       expect(value.length).toEqual(2);
+     });
+
+    $httpBackend.expectPOST('/places').respond(function(method, url, data, headers) {
+      return [201, angular.fromJson(data), ""];
+    });
+
+    $httpBackend.flush();
+   });
+
+    it("post() should add a new item with data and return the data from the server", function() {
+     restangularAccounts.post(newAccount).then(function(added) {
+       expect(added.fromServer).toEqual(true);
+       expect(added.id).toEqual(newAccount.id);
+     });
+
+    $httpBackend.expectPOST('/accounts');
+    $httpBackend.flush();
+   });
+
+    it("Doing a post and then other operation (delete) should call right URLs", function() {
+      restangularAccounts.post(newAccount).then(function(added) {
+        added.remove();
+        $httpBackend.expectDELETE('/accounts/44').respond(201, '');
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("Doing a post to a server that returns no element will return undefined", function() {
+      restangularAccounts.getList().then(function(accounts) {
+        var newTransaction = {id: 1, name: "Gonto"};
+        accounts[1].post('transactions', newTransaction).then(function(transaction) {
+          expect(transaction).toBeUndefined();
+        });
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("head() should safely return", function() {
+      restangularAccounts.head().then(function() {
+        expect(true).toBe(true);
+      });
+      $httpBackend.flush();
+    });
+
+    it("trace()  should safely return", function() {
+      restangularAccounts.trace().then(function() {
+        expect(true).toBe(true);
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("customPUT should work", function() {
+      $httpBackend.expectPUT('/accounts/hey').respond(accountsModel);
+      restangularAccounts.customPUT({key: 'value'}, 'hey');
+
+      $httpBackend.flush();
+    });
+
+    it("options()  should safely return", function() {
+      restangularAccounts.options().then(function() {
+        expect(true).toBe(true);
+      });
+
+      $httpBackend.flush();
+    });
+
+     it("getList() should correctly handle params after customDELETE", function() {
+      $httpBackend.expectGET('/accounts?foo=1').respond(accountsModel);
+      restangularAccounts.getList({foo: 1}).then(function(){
+        $httpBackend.expectDELETE('/accounts?id=1').respond(201, '');
+        return restangularAccounts.customDELETE('', {id: 1});
+      }).then(function() {
+          $httpBackend.expectGET('/accounts?foo=1').respond(accountsModel);
+          return restangularAccounts.getList({foo: 1});
+        }).then(function(accounts) {
+          expect(Restangular.stripRestangular(accounts)).toEqual(Restangular.stripRestangular(accountsModel));
+        });
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("Scoped Service", function() {
+
+    it("should correctly work", function() {
+      var Accounts = Restangular.service('accounts');
+      Accounts.post(newAccount);
+      Accounts.one(0).get();
+      Accounts.getList();
+
+      $httpBackend.expectPOST('/accounts');
+      $httpBackend.expectGET('/accounts/0');
+      $httpBackend.expectGET('/accounts');
+      $httpBackend.flush();
+     });
+
+    it("should correctly work with children", function() {
+      var Transactions = Restangular.service('transactions', restangularAccount1);
+      Transactions.post(newAccount);
+      Transactions.one(1).get();
+      Transactions.getList();
+
+      $httpBackend.expectPOST('/accounts/1/transactions');
+      $httpBackend.expectGET('/accounts/1/transactions/1');
+      $httpBackend.expectGET('/accounts/1/transactions');
+      $httpBackend.flush();
+     });
+
+    it("should add custom collection method added with withConfig", function() {
+      var Accounts = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.addElementTransformer('accounts', true, function(worker) {
+          worker.addRestangularMethod('doSomething', 'get', 'do-something');
+          return worker;
+        });
+      }).service('accounts');
+
+      expect(Accounts.doSomething).toBeDefined();
+      expect(_.isFunction(Accounts.doSomething)).toBeTruthy();
+
+      Accounts.post(newAccount);
+      Accounts.one(0).get();
+      Accounts.getList();
+      Accounts.doSomething();
+
+      $httpBackend.expectPOST('/accounts');
+      $httpBackend.expectGET('/accounts/0');
+      $httpBackend.expectGET('/accounts');
+      $httpBackend.expectGET('/accounts/do-something');
+      $httpBackend.flush();
+    });
+  });
+
+  describe("ONE", function() {
+    it("get() should return a JSON item", function() {
+      restangularAccount1.get().then(function(account) {
+        expect(Restangular.stripRestangular(account))
+          .toEqual(Restangular.stripRestangular(accountsModel[1]));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("Should save as put correctly", function() {
+      restangularAccount1.get().then(function(account) {
+        $httpBackend.expectPUT('/accounts/1');
+        account.put();
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("Should save as post correctly", function() {
+      var account1 = angular.copy(restangularAccount1);
+      $httpBackend.expectPOST('/accounts/1');
+      account1.name = "Hey";
+      account1.save();
+
+      $httpBackend.flush();
+    });
+
+    it("Should keep route property when element is created", function() {
+      var account1 = Restangular.restangularizeElement(null, {}, 'accounts');
+      $httpBackend.expectPOST('/accounts');
+      $httpBackend.expectPUT('/accounts/1');
+      account1.name = "Hey";
+      account1.save().then(function(accountFromServer) {
+        accountFromServer.id = 1;
+        return accountFromServer.save();
+      }).then(function(accountFromServer2) {
+        expect(accountFromServer2.route).toBe(account1.route);
+      });
+      $httpBackend.flush()
+    });
+
+    it("Should make RequestLess connections with one", function() {
+      restangularAccount1.one("transactions", 1).get().then(function(transaction) {
+        expect(Restangular.stripRestangular(transaction))
+          .toEqual(Restangular.stripRestangular(accountsModel[1].transactions[1]));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("Should make RequestLess connections with all", function() {
+      restangularAccount1.all("transactions").getList().then(function(transactions) {
+        expect(Restangular.stripRestangular(transactions))
+          .toEqual(Restangular.stripRestangular(accountsModel[1].transactions));
+      });
+
+      $httpBackend.flush();
+    });
+
+
+    it("Custom GET methods should work", function() {
+      restangularAccount1.customGET("message").then(function(msg) {
+        expect(Restangular.stripRestangular(msg)).toEqual(Restangular.stripRestangular(messages[0]));
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("put() should update the value", function() {
+      restangularAccount1.get().then(function(account) {
+        account.amount = 1.618;
+        account.put().then(function(newAc) {
+          expect(accountsModel[1].amount).toEqual(1.618);
+          newAc.remove();
+          $httpBackend.expectDELETE("/accounts/1");
+        });
+        $httpBackend.expectPUT("/accounts/1");
+
+
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("should return an array when accessing a subvalue", function() {
+      restangularAccount1.get().then(function(account) {
+        account.getList("transactions").then(function(transactions) {
+          expect(Restangular.stripRestangular(transactions))
+            .toEqual(Restangular.stripRestangular(accountsModel[1].transactions));
+        });
+      });
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("COPY", function() {
+    it("should copy an object and 'this' should reference the copied object", function() {
+      var copiedAccount = Restangular.copy(accountsModel[0]);
+      var that;
+
+      copiedAccount.user = "Copied string";
+      expect(copiedAccount).not.toBe(accountsModel[0]);
+
+      // create a spy for one of the methods to capture the value of 'this'
+      spyOn(copiedAccount, 'getRestangularUrl').andCallFake(function() {
+        that = this;
+      });
+
+      copiedAccount.getRestangularUrl(); // invoke the method we are spying on
+      expect(that).toBe(copiedAccount);
+    });
+  });
+
+  describe("getRestangularUrl", function() {
+    it("should return the generated URL when you chain Restangular methods together", function() {
+      var restangularSpaces = Restangular.one("accounts",123).one("buildings", 456).all("spaces");
+      expect(restangularSpaces.getRestangularUrl()).toEqual("/accounts/123/buildings/456/spaces");
+    });
+  });
+
+  describe("getRestangularUrl with useCannonicalId set to true", function() {
+    it("should return the generated URL when you chain Restangular methods together", function() {
+      var R = Restangular.withConfig(function(config) {
+        config.setUseCannonicalId(true);
+      });
+      var restangularSpaces = R.one("accounts",123).one("buildings", 456).all("spaces");
+      expect(restangularSpaces.getRestangularUrl()).toEqual("/accounts/123/buildings/456/spaces");
+    });
+  });
+
+
+  describe("addElementTransformer", function() {
+    it("should allow for a custom method to be placed at the collection level", function() {
+      var accountsPromise;
+
+      Restangular.addElementTransformer('accounts', true, function(collection) {
+         collection.totalAmount = function() {};
+         return collection;
+      });
+
+      accountsPromise = Restangular.all('accounts').getList();
+
+      accountsPromise.then(function(accounts) {
+        expect(typeof accounts.totalAmount).toEqual("function");
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("should allow for a custom method to be placed at the model level when one model is requested", function() {
+      var accountPromise;
+
+      Restangular.addElementTransformer('accounts', false, function(model) {
+         model.prettifyAmount = function() {};
+         return model;
+      });
+
+      accountPromise = Restangular.one('accounts', 1).get();
+
+      accountPromise.then(function(account) {
+        expect(typeof account.prettifyAmount).toEqual("function");
+      });
+
+      $httpBackend.flush();
+    });
+
+    it("should allow for a custom method to be placed at the model level when several models are requested", function() {
+      var accountPromise;
+
+      Restangular.addElementTransformer('accounts', false, function(model) {
+         model.prettifyAmount = function() {};
+         return model;
+      });
+
+      accountsPromise = Restangular.all('accounts', 1).getList();
+
+      accountsPromise.then(function(accounts) {
+        accounts.forEach(function(account, index) {
+          expect(typeof account.prettifyAmount).toEqual("function");
+        });
+      });
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("extendCollection", function() {
+    it("should be an alias for a specific invocation of addElementTransformer", function() {
+      var spy = spyOn(Restangular, 'addElementTransformer');
+
+      var fn = function(collection) {
+        collection.totalAmount = function() {};
+        return collection;
+      };
+
+      Restangular.extendCollection('accounts', fn);
+
+      expect(spy).toHaveBeenCalledWith('accounts', true, fn);
+    });
+  });
+
+  describe("extendModel", function() {
+    it("should be an alias for a specific invocation of addElementTransformer", function() {
+      var spy = spyOn(Restangular, 'addElementTransformer');
+
+      var fn = function(model) {
+        model.prettifyAmount = function() {};
+        return model;
+      };
+
+      Restangular.extendModel('accounts', fn);
+
+      expect(spy).toHaveBeenCalledWith('accounts', false, fn);
+    });
+  });
+
+  describe("headers", function() {
+    it("should return defaultHeaders", function() {
+      var defaultHeaders = {testheader:'header value'};
+      Restangular.setDefaultHeaders(defaultHeaders);
+      expect(Restangular.defaultHeaders).toEqual(defaultHeaders);
+    });
+
+    it("should pass uppercase methods in X-HTTP-Method-Override", function() {
+      Restangular.setMethodOverriders(["put"]);
+      $httpBackend.expectPOST('/overriders/1').respond(function(method, url, data, headers) {
+        expect(headers['X-HTTP-Method-Override']).toBe('PUT');
+        return {};
+      });
+      Restangular.one('overriders', 1).put();
+      $httpBackend.flush();
+    });
+  });
+
+  describe("defaultRequestParams", function() {
+    it("should return defaultRequestParams", function() {
+      var defaultRequestParams = {param:'value'};
+
+      Restangular.setDefaultRequestParams(defaultRequestParams);
+
+      expect(Restangular.requestParams.common).toEqual(defaultRequestParams);
+    });
+
+    it("should be able to set default params for get, post, put.. methods separately", function() {
+      var postParams = {post:'value'},
+          putParams = {put:'value'};
+
+      Restangular.setDefaultRequestParams('post', postParams);
+      expect(Restangular.requestParams.post).toEqual(postParams);
+
+      Restangular.setDefaultRequestParams('put', putParams);
+      expect(Restangular.requestParams.put).toEqual(putParams);
+
+      expect(Restangular.requestParams.common).not.toEqual(putParams);
+    });
+
+    it("should be able to set default params for multiple methods with array", function() {
+      var defaultParams = {param:'value'};
+
+      Restangular.setDefaultRequestParams(['post', 'put'], defaultParams);
+
+      expect(Restangular.requestParams.post).toEqual(defaultParams);
+      expect(Restangular.requestParams.put).toEqual(defaultParams);
+
+      expect(Restangular.requestParams.common).not.toEqual(defaultParams);
+    });
+  });
+
+  describe("withConfig", function() {
+    it("should create new service with scoped configuration", function() {
+      var childRestangular = Restangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setBaseUrl('/api/v1');
+      });
+
+      expect(Restangular.configuration.baseUrl).toEqual('');
+      expect(childRestangular.configuration.baseUrl).toEqual('/api/v1');
+
+    });
+
+    it("should allow nested configurations", function() {
+      var childRestangular = Restangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setBaseUrl('/api/v1');
+      });
+
+      var grandchildRestangular = childRestangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setRequestSuffix('.json');
+      });
+
+      expect(Restangular.configuration.baseUrl).toEqual('');
+      expect(Restangular.configuration.suffix).toEqual(null);
+
+      expect(childRestangular.configuration.baseUrl).toEqual('/api/v1');
+      expect(childRestangular.configuration.suffix).toEqual(null);
+
+      expect(grandchildRestangular.configuration.baseUrl).toEqual('/api/v1');
+      expect(grandchildRestangular.configuration.suffix).toEqual('.json');
+    });
+  });
+
+  describe("Self linking", function() {
+    it("Should request the link in HAL format", function() {
+      var linkRestangular = Restangular.withConfig(function(RestangularConfigurer) {
+        RestangularConfigurer.setRestangularFields({
+          selfLink: "_links.self"
+        });
+      });
+
+      var arr = linkRestangular.all('accountsHAL').getList().$object;
+      $httpBackend.flush();
+
+      var account = arr[0];
+      $httpBackend.expectPUT("/accountsHAL/martin");
+      account.name = "Updated";
+      account.put();
+
+      $httpBackend.flush();
+    });
+  });
+
+  describe("Singe one (endpoint not expecting an id)", function() {
+    it('does not use the id for single resource GET', function() {
+      Restangular.one('info', 0, true).get();
+      $httpBackend.expectGET('/info');
+      $httpBackend.flush();
+    });
+
+    it('getRestangularUrl() returns still the url without id after GET', function() {
+      record = Restangular.one('info', 0, true);
+      record.get().then(function(data){
+        expect(data.getRestangularUrl()).toEqual("/info")
+      });
+      $httpBackend.expectGET('/info');
+      $httpBackend.flush();
+    });
+
+    it('does not use the id for single nested resource GET', function() {
+      Restangular.one('accounts', 1).one('info', 0, true).get()
+      $httpBackend.expectGET('/accounts/1/info');
+      $httpBackend.flush();
+    });
+
+    it('does not use the id for single resource PUT', function() {
+      Restangular.one('info', 0, true).put();
+      $httpBackend.expectPUT('/info');
+      $httpBackend.flush();
+    });
+  });
+
+  describe("setSelfLinkAbsoluteUrl", function() {
+    it("works", function() {
+      var childRestangular = Restangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setSelfLinkAbsoluteUrl(false);
+      });
+
+      expect(Restangular.configuration.absoluteUrl).toEqual(true);
+      expect(childRestangular.configuration.absoluteUrl).toEqual(false);
+    })
+  });
+
+  describe("Misc", function () {
+    it("should not strip [one] or [all] key from plain object", function () {
+      Restangular.all("customs").customPOST({one: 'I am here', two: 'I am also here'}).then(function () {
+        expect(1).toBe(1);
+      }, function () {
+        expect("Promise").toBe("correctly fulfilled");
+      });
+      $httpBackend.flush();
+    });
+
+    it("should not stip non-restangularized elements", function () {
+      expect(Restangular.stripRestangular(["test","test2"])).toEqual(["test","test2"]);
+    });
+  });
+
+  describe("testing normilize url", function () {
+
+    it("should get a list of objects", function () {
+      Restangular.all('customers/').getList().then(function(res){
+        res.getList({active: true});
+        $httpBackend.expectGET('/customers/?active=true');
+        //res.getList('publications/', {tags: 'chemistry'});
+        //$httpBackend.expectGET('/customers/publications/?tags=chemistry');
+      });
+      $httpBackend.expectGET('/customers/');
+      $httpBackend.flush();
+    });
+
+    it("should get a list of objects even if the path has extra slashes", function () {
+      Restangular.all('customers///').getList().then(function(res){
+        res.getList({active: true});
+        $httpBackend.expectGET('/customers/?active=true');
+      });
+      $httpBackend.expectGET('/customers/');
+      $httpBackend.flush();
+    });
+
+    it("should post with slash at the end", function () {
+      Restangular.all('customers/').getList().then(function(res){
+        res.post(newCustomer);
+        $httpBackend.expectPOST('/customers/');
+      });
+      $httpBackend.expectGET('/customers/');
+      $httpBackend.flush();
+    });
+
+    it("should put with slash at the end", function () {
+      Restangular.all('customers/').getList().then(function(customers){
+        customers[0].put();
+        $httpBackend.expectPUT('/customers/0');
+      });
+      $httpBackend.flush();
+    });
+
+    it("should return a normilized URL even it has extra slashes", function() {
+      var restangularSpaces = Restangular.one("accounts//", 123).one("buildings//", 456).all("spaces///");
+      expect(restangularSpaces.getRestangularUrl()).toEqual("/accounts/123/buildings/456/spaces/");
+    });
+
+    it("should create a new service and still working normilized URL", function() {
+      var newRes = Restangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setBaseUrl('http://localhost:8080');
+      });
+      expect(newRes.configuration.baseUrl).toEqual('http://localhost:8080');
+      newRes.all("customers////").getList();
+      $httpBackend.expectGET('http://localhost:8080/customers/');
+
+      var newApi = Restangular.withConfig(function(RestangularConfigurer){
+        RestangularConfigurer.setBaseUrl('api.new.domain');
+      });
+
+      expect(newApi.configuration.baseUrl).toEqual('api.new.domain');
+      newApi.all("customers////").getList();
+      $httpBackend.expectGET('api.new.domain/customers/');
+
+      $httpBackend.flush();
+    });
+  });
+});