| /* |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| 'use strict' |
| |
| var should = require('should'), |
| urljoin = require('url-join'), |
| config = require('../../helpers').config, |
| UsergridClient = require('../../lib/client'), |
| UsergridEntity = require('../../lib/entity'), |
| UsergridQuery = require('../../lib/query'), |
| UsergridAuth = require('../../lib/auth'), |
| UsergridAsset = require('../../lib/asset'), |
| fs = require('fs') |
| |
| var _slow = 1500, |
| _timeout = 4000, |
| filename = 'old_man', |
| file = __dirname + '/image.jpg', |
| expectedContentLength = 109055, |
| assetEntity = new UsergridEntity({ |
| type: config.test.collection, |
| info: "assetTestEntity" |
| }) |
| |
| describe('putProperty()', function() { |
| it('should set the value for a given key if the key does not exist', function() { |
| var entity = new UsergridEntity('cat', 'Cosmo') |
| entity.putProperty('foo', ['bar']) |
| entity.should.have.property('foo').deepEqual(['bar']) |
| }) |
| |
| it('should overwrite the value for a given key if the key exists', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'baz' |
| }) |
| entity.putProperty('foo', 'bar') |
| entity.should.have.property('foo').deepEqual('bar') |
| }) |
| |
| it('should not be able to set the name key (name is immutable)', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'baz' |
| }) |
| should(function() { |
| entity.putProperty('name', 'Bazinga') |
| }).throw() |
| }) |
| }) |
| |
| describe('putProperties()', function() { |
| it('should set properties for a given object, overwriting properties that exist and creating those that don\'t', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'bar' |
| }) |
| entity.putProperties({ |
| foo: 'baz', |
| qux: 'quux', |
| barray: [1, 2, 3, 4] |
| }) |
| entity.should.containEql({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'baz', |
| qux: 'quux', |
| barray: [1, 2, 3, 4] |
| }) |
| }) |
| |
| it('should not be able to set properties for immutable keys', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'baz' |
| }) |
| entity.putProperties({ |
| name: 'Bazinga', |
| uuid: 'BadUuid', |
| bar: 'qux' |
| }) |
| entity.should.containEql({ |
| type: 'cat', |
| name: 'Cosmo', |
| bar: 'qux', |
| foo: 'baz' |
| }) |
| }) |
| }) |
| |
| describe('removeProperty()', function() { |
| it('should remove a given property if it exists', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'baz' |
| }) |
| entity.removeProperty('foo') |
| entity.should.not.have.property('foo') |
| }) |
| |
| it('should fail gracefully when removing an undefined property', function() { |
| var entity = new UsergridEntity('cat', 'Cosmo') |
| entity.removeProperty('foo') |
| entity.should.not.have.property('foo') |
| }) |
| }) |
| |
| describe('removeProperties()', function() { |
| it('should remove an array of properties for a given object, failing gracefully for undefined properties', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'bar', |
| baz: 'qux' |
| }) |
| entity.removeProperties(['foo', 'baz']) |
| entity.should.containEql({ |
| type: 'cat', |
| name: 'Cosmo' |
| }) |
| }) |
| }) |
| |
| describe('insert()', function() { |
| it('should insert a single value into an existing array at the specified index', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3, 5, 6] |
| }) |
| entity.insert('foo', 4, 3) |
| entity.should.have.property('foo').deepEqual([1, 2, 3, 4, 5, 6]) |
| }) |
| |
| it('should merge an array of values into an existing array at the specified index', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3, 7, 8] |
| }) |
| entity.insert('foo', [4, 5, 6], 3) |
| entity.should.have.property('foo').deepEqual([1, 2, 3, 4, 5, 6, 7, 8]) |
| }) |
| |
| it('should convert an existing value into an array when inserting a second value', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'bar' |
| }) |
| entity.insert('foo', 'baz', 1) |
| entity.should.have.property('foo').deepEqual(['bar', 'baz']) |
| }) |
| |
| it('should create a new array when a property does not exist', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo' |
| }) |
| entity.insert('foo', 'bar', 1000) |
| entity.should.have.property('foo').deepEqual(['bar']) |
| }) |
| |
| it('should gracefully handle indexes out of range', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: ['bar'] |
| }) |
| entity.insert('foo', 'baz', 1000) |
| entity.should.have.property('foo').deepEqual(['bar', 'baz']) |
| entity.insert('foo', 'qux', -1000) |
| entity.should.have.property('foo').deepEqual(['qux', 'bar', 'baz']) |
| }) |
| }) |
| |
| describe('append()', function() { |
| it('should append a value to the end of an existing array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3] |
| }) |
| entity.append('foo', 4) |
| entity.should.have.property('foo').deepEqual([1, 2, 3, 4]) |
| }) |
| |
| it('should create a new array if a property does not exist', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo' |
| }) |
| entity.append('foo', 'bar') |
| entity.should.have.property('foo').deepEqual(['bar']) |
| }) |
| }) |
| |
| describe('prepend()', function() { |
| it('should prepend a value to the beginning of an existing array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3] |
| }) |
| entity.prepend('foo', 0) |
| entity.should.have.property('foo').deepEqual([0, 1, 2, 3]) |
| }) |
| |
| it('should create a new array if a property does not exist', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo' |
| }) |
| entity.prepend('foo', 'bar') |
| entity.should.have.property('foo').deepEqual(['bar']) |
| }) |
| }) |
| |
| describe('pop()', function() { |
| it('should remove the last value of an existing array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3] |
| }) |
| entity.pop('foo') |
| entity.should.have.property('foo').deepEqual([1, 2]) |
| }) |
| |
| it('value should remain unchanged if it is not an array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'bar' |
| }) |
| entity.pop('foo') |
| entity.should.have.property('foo').deepEqual('bar') |
| }) |
| |
| it('should gracefully handle empty arrays', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [] |
| }) |
| entity.pop('foo') |
| entity.should.have.property('foo').deepEqual([]) |
| }) |
| }) |
| |
| describe('shift()', function() { |
| it('should remove the first value of an existing array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [1, 2, 3] |
| }) |
| entity.shift('foo') |
| entity.should.have.property('foo').deepEqual([2, 3]) |
| }) |
| |
| it('value should remain unchanged if it is not an array', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: 'bar' |
| }) |
| entity.shift('foo') |
| entity.should.have.property('foo').deepEqual('bar') |
| }) |
| |
| it('should gracefully handle empty arrays', function() { |
| var entity = new UsergridEntity({ |
| type: 'cat', |
| name: 'Cosmo', |
| foo: [] |
| }) |
| entity.shift('foo') |
| entity.should.have.property('foo').deepEqual([]) |
| }) |
| }) |
| |
| describe('reload()', function() { |
| |
| this.slow(_slow + 1000) |
| this.timeout(_timeout + 4000) |
| |
| it('should refresh an entity with the latest server copy of itself', function(done) { |
| var client = new UsergridClient(config), |
| now = Date.now() |
| client.GET(config.test.collection, function(err, getResponse) { |
| var entity = new UsergridEntity(getResponse.first) |
| var modified = entity.modified |
| getResponse.first.putProperty('reloadTest', now) |
| client.PUT(getResponse.first, function() { |
| entity.reload(client, function() { |
| client.isSharedInstance.should.be.false() |
| entity.reloadTest.should.equal(now) |
| entity.modified.should.not.equal(modified) |
| done() |
| }) |
| }) |
| }) |
| }) |
| }) |
| |
| describe('save()', function() { |
| |
| this.slow(_slow + 1000) |
| this.timeout(_timeout + 4000) |
| |
| it('should save an updated entity to the server', function(done) { |
| var client = new UsergridClient(config), |
| now = Date.now() |
| client.GET(config.test.collection, function(err, getResponse) { |
| var entity = new UsergridEntity(getResponse.first) |
| entity.putProperty('saveTest', now) |
| entity.save(client, function() { |
| client.isSharedInstance.should.be.false() |
| entity.saveTest.should.equal(now) |
| done() |
| }) |
| }) |
| }) |
| }) |
| |
| describe('remove()', function() { |
| |
| this.slow(_slow + 1000) |
| this.timeout(_timeout + 4000) |
| |
| it('should remove an entity from the server', function(done) { |
| var client = new UsergridClient(config) |
| client.POST(config.test.collection, { |
| removeTest: 'test' |
| }, function(err, postResponse) { |
| var entity = new UsergridEntity(postResponse.first) |
| entity.remove(client, function(err, deleteResponse) { |
| client.isSharedInstance.should.be.false() |
| deleteResponse.ok.should.be.true() |
| // best practice is to desroy the 'entity' instance here, because it no longer exists on the server |
| entity = null |
| done() |
| }) |
| }) |
| }) |
| }) |
| |
| describe('attachAsset()', function() { |
| |
| var asset = new UsergridAsset(filename, file), |
| entity = new UsergridEntity({ |
| type: config.test.collection, |
| info: "attachAssetTest" |
| }) |
| before(function(done) { |
| fs.readFile(file, function(err, data) { |
| asset.data = data |
| done() |
| }) |
| }) |
| |
| it('should attach a UsergridAsset to the entity', function(done) { |
| entity.attachAsset(asset) |
| entity.should.have.property('asset').equal(asset) |
| done() |
| }) |
| }) |
| |
| describe('uploadAsset()', function() { |
| |
| this.slow(_slow) |
| this.timeout(_timeout) |
| |
| var asset = new UsergridAsset(filename, file) |
| before(function(done) { |
| fs.readFile(file, function(err, data) { |
| asset.data = data |
| done() |
| }) |
| }) |
| |
| it('should upload an image asset to the remote entity', function(done) { |
| var client = new UsergridClient(config) |
| assetEntity.attachAsset(asset) |
| assetEntity.uploadAsset(client, function(err, usergridResponse, entity) { |
| assetEntity = entity |
| entity.should.have.property('file-metadata') |
| entity['file-metadata'].should.have.property('content-length').equal(expectedContentLength) |
| entity['file-metadata'].should.have.property('content-type').equal('image/jpeg') |
| done() |
| }) |
| }) |
| }) |
| |
| describe('downloadAsset()', function() { |
| |
| this.slow(_slow) |
| this.timeout(_timeout) |
| |
| it('should download a an image from the remote entity', function(done) { |
| var client = new UsergridClient(config) |
| assetEntity.downloadAsset(client, 'image/jpeg', function(err, usergridResponse, entityWithAsset) { |
| entityWithAsset.should.have.property('asset').which.is.an.instanceof(UsergridAsset) |
| entityWithAsset.asset.should.have.property('contentType').equal(assetEntity['file-metadata']['content-type']) |
| entityWithAsset.asset.should.have.property('contentLength').equal(assetEntity['file-metadata']['content-length']) |
| // clean up the now un-needed asset entity |
| entityWithAsset.remove(client) |
| done() |
| }) |
| }) |
| }) |
| |
| describe('connect()', function() { |
| |
| this.slow(_slow) |
| this.timeout(_timeout + 4000) |
| |
| var response, |
| entity1, |
| entity2, |
| client = new UsergridClient(), |
| query = new UsergridQuery(config.test.collection).eq('name', 'testEntityConnectOne').or.eq('name', 'testEntityConnectTwo').asc('name') |
| |
| before(function(done) { |
| // Create the entities we're going to use for connections |
| client.POST(config.test.collection, [{ |
| "name": "testEntityConnectOne" |
| }, { |
| "name": "testEntityConnectTwo" |
| }], function() { |
| client.GET(query, function(err, usergridResponse) { |
| response = usergridResponse |
| entity1 = response.first |
| entity2 = response.last |
| done() |
| }) |
| }) |
| }) |
| |
| it('should connect entities by passing a target UsergridEntity object as a parameter', function(done) { |
| var relationship = "foos" |
| |
| entity1.connect(client, relationship, entity2, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.first.metadata.connecting[relationship].should.equal(urljoin( |
| "", |
| config.test.collection, |
| entity1.uuid, |
| relationship, |
| entity2.uuid, |
| "connecting", |
| relationship |
| )) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should connect entities by passing target uuid as a parameter', function(done) { |
| var relationship = "bars" |
| |
| entity1.connect(client, relationship, entity2.uuid, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.first.metadata.connecting[relationship].should.equal(urljoin( |
| "", |
| config.test.collection, |
| entity1.uuid, |
| relationship, |
| entity2.uuid, |
| "connecting", |
| relationship |
| )) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should connect entities by passing target type and name as parameters', function(done) { |
| var relationship = "bazzes" |
| |
| entity1.connect(client, relationship, entity2.type, entity2.name, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.first.metadata.connecting[relationship].should.equal(urljoin( |
| "", |
| config.test.collection, |
| entity1.uuid, |
| relationship, |
| entity2.uuid, |
| "connecting", |
| relationship |
| )) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should fail to connect entities when specifying target name without type', function() { |
| should(function() { |
| entity1.connect("fails", 'badName', function() {}) |
| }).throw() |
| }) |
| }) |
| |
| describe('getConnections()', function() { |
| |
| this.slow(_slow) |
| this.timeout(_timeout + 4000) |
| |
| var response, |
| client = new UsergridClient(), |
| query = new UsergridQuery(config.test.collection).eq('name', 'testEntityConnectOne').or.eq('name', 'testEntityConnectTwo').asc('name') |
| |
| before(function(done) { |
| client.GET(query, function(err, usergridResponse) { |
| response = usergridResponse |
| done() |
| }) |
| }) |
| |
| it('should get an entity\'s outbound connections', function(done) { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| var relationship = "foos" |
| |
| entity1.getConnections(client, UsergridClient.Connections.DIRECTION_OUT, relationship, function(err, usergridResponse) { |
| usergridResponse.first.metadata.connecting[relationship].should.equal(urljoin( |
| "", |
| config.test.collection, |
| entity1.uuid, |
| relationship, |
| entity2.uuid, |
| "connecting", |
| relationship |
| )) |
| done() |
| }) |
| }) |
| |
| it('should get an entity\'s inbound connections', function(done) { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| var relationship = "foos" |
| |
| entity2.getConnections(client, UsergridClient.Connections.DIRECTION_IN, relationship, function(err, usergridResponse) { |
| usergridResponse.first.metadata.connections[relationship].should.equal(urljoin( |
| "", |
| config.test.collection, |
| entity2.uuid, |
| "connecting", |
| entity1.uuid, |
| relationship |
| )) |
| done() |
| }) |
| }) |
| }) |
| |
| describe('disconnect()', function() { |
| |
| this.slow(_slow) |
| this.timeout(_timeout + 4000) |
| |
| var response, |
| client = new UsergridClient(), |
| query = new UsergridQuery(config.test.collection).eq('name', 'testEntityConnectOne').or.eq('name', 'testEntityConnectTwo').asc('name') |
| |
| before(function(done) { |
| client.GET(query, function(err, usergridResponse) { |
| response = usergridResponse |
| done() |
| }) |
| }) |
| |
| it('should disconnect entities by passing a target UsergridEntity object as a parameter', function(done) { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| var relationship = "foos" |
| |
| entity1.disconnect(client, relationship, entity2, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.entities.should.be.an.Array().with.lengthOf(0) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should disconnect entities by passing target uuid as a parameter', function(done) { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| var relationship = "bars" |
| |
| entity1.disconnect(client, relationship, entity2.uuid, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.entities.should.be.an.Array().with.lengthOf(0) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should disconnect entities by passing target type and name as parameters', function(done) { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| var relationship = "bazzes" |
| |
| entity1.disconnect(client, relationship, entity2.type, entity2.name, function(err, usergridResponse) { |
| usergridResponse.ok.should.be.true() |
| client.getConnections(UsergridClient.Connections.DIRECTION_OUT, entity1, relationship, function(err, usergridResponse) { |
| usergridResponse.entities.should.be.an.Array().with.lengthOf(0) |
| done() |
| }) |
| }) |
| }) |
| |
| it('should fail to disconnect entities when specifying target name without type', function() { |
| var entity1 = response.first |
| var entity2 = response.last |
| |
| should(function() { |
| entity1.disconnect("fails", entity2.name, function() {}) |
| }).throw() |
| }) |
| }) |
| |
| describe('usingAuth()', function() { |
| |
| this.slow(_slow + 500) |
| this.timeout(_timeout) |
| |
| var client = new UsergridClient(), |
| authFromToken = new UsergridAuth('BADTOKEN'), |
| _entity |
| |
| it('should fail to reload an entity when using a bad ad-hoc token', function(done) { |
| client.GET(config.test.collection, function(err, getResponse) { |
| _entity = new UsergridEntity(getResponse.first) |
| _entity.usingAuth(authFromToken).reload(client, function(error, usergridResponse) { |
| usergridResponse.request.headers.should.not.have.property('authentication') |
| usergridResponse.ok.should.be.false() |
| error.name.should.equal('auth_bad_access_token') |
| done() |
| }) |
| }) |
| }) |
| |
| it('client.tempAuth should be destroyed after making a request with ad-hoc authentication', function(done) { |
| should(client.tempAuth).be.undefined() |
| done() |
| }) |
| |
| it('entity.tempAuth should be destroyed after making a request with ad-hoc authentication', function(done) { |
| should(_entity.tempAuth).be.undefined() |
| done() |
| }) |
| |
| it('should send an unauthenticated request when UsergridAuth.NO_AUTH is passed to .usingAuth()', function(done) { |
| // hack this using 'me' in case test apps have sandbox permissions |
| var entity = new UsergridEntity({ |
| uuid: 'me', |
| type: 'users' |
| }) |
| entity.usingAuth(UsergridAuth.NO_AUTH).reload(client, function(error, usergridResponse) { |
| usergridResponse.request.headers.should.not.have.property('authentication') |
| usergridResponse.ok.should.be.false() |
| error.name.should.equal('service_resource_not_found') |
| done() |
| }) |
| }) |
| |
| it('should send an unauthenticated request when no arguments are passed to .usingAuth()', function(done) { |
| // hack this using 'me' in case test apps have sandbox permissions |
| var entity = new UsergridEntity({ |
| uuid: 'me', |
| type: 'users' |
| }) |
| entity.usingAuth().reload(client, function(error, usergridResponse) { |
| usergridResponse.request.headers.should.not.have.property('authentication') |
| usergridResponse.ok.should.be.false() |
| error.name.should.equal('service_resource_not_found') |
| done() |
| }) |
| }) |
| }) |
