From c064a32434b4bc0b9b383320fa9d5b23c4d6fdd9 Mon Sep 17 00:00:00 2001 From: Ashley Date: Fri, 15 Jul 2016 18:11:49 -0400 Subject: [PATCH] adding unit tests --- lib/compute/region.js | 3 +- test/compute/index.js | 108 +++++++++++++++++++ test/compute/network.js | 66 ++++++++++++ test/compute/region.js | 213 ++++++++++++++++++++++++++++++++++++- test/compute/subnetwork.js | 186 ++++++++++++++++++++++++++++++++ 5 files changed, 574 insertions(+), 2 deletions(-) create mode 100644 test/compute/subnetwork.js diff --git a/lib/compute/region.js b/lib/compute/region.js index e3b5114e9b5..bc7da548884 100644 --- a/lib/compute/region.js +++ b/lib/compute/region.js @@ -813,6 +813,7 @@ Region.prototype.rule = function(name) { * These methods can be used with either a callback or as a readable object * stream. `streamRouter` is used to add this dual behavior. */ -streamRouter.extend(Region, ['getAddresses', 'getOperations', 'getRules', 'getSubnetworks']); +streamRouter.extend(Region, + ['getAddresses', 'getOperations', 'getRules', 'getSubnetworks']); module.exports = Region; diff --git a/test/compute/index.js b/test/compute/index.js index 77f7c350baf..f54e3cd3313 100644 --- a/test/compute/index.js +++ b/test/compute/index.js @@ -79,6 +79,7 @@ function FakeOperation() { function FakeRegion() { this.calledWith_ = slice.call(arguments); this.address = function() { return {}; }; + this.subnetwork = function() { return {}; }; } function FakeRule() { @@ -1140,6 +1141,113 @@ describe('Compute', function() { }); }); + describe('getSubnetworks', function() { + it('should accept only a callback', function(done) { + compute.request = function(reqOpts) { + assert.deepEqual(reqOpts.qs, {}); + done(); + }; + + compute.getSubnetworks(assert.ifError); + }); + + it('should make the correct API request', function(done) { + var options = {}; + + compute.request = function(reqOpts) { + assert.strictEqual(reqOpts.uri, '/aggregated/subnetworks'); + assert.strictEqual(reqOpts.qs, options); + done(); + }; + + compute.getSubnetworks(options, assert.ifError); + }); + + describe('error', function() { + var error = new Error('Error.'); + var apiResponse = { a: 'b', c: 'd' }; + + beforeEach(function() { + compute.request = function(reqOpts, callback) { + callback(error, apiResponse); + }; + }); + + it('should execute callback with error & API response', function(done) { + compute.getSubnetworks({}, function(err, subnetworks, nextQuery, resp) { + assert.strictEqual(err, error); + assert.strictEqual(subnetworks, null); + assert.strictEqual(nextQuery, null); + assert.strictEqual(resp, apiResponse); + + done(); + }); + }); + }); + + describe('success', function() { + var REGION_NAME = 'region-1'; + var FULL_REGION_NAME = 'regions/' + REGION_NAME; + + var subnetwork = { name: 'subnetwork-1' }; + var apiResponse = { + items: {} + }; + + apiResponse.items[FULL_REGION_NAME] = { + subnetworks: [subnetwork] + }; + + beforeEach(function() { + compute.request = function(reqOpts, callback) { + callback(null, apiResponse); + }; + }); + + it('should create Subnetwork objects from the response', function(done) { + var region = {}; + + compute.region = function(name) { + assert.strictEqual(name, REGION_NAME); + return region; + }; + + region.subnetwork = function(name) { + assert.strictEqual(name, subnetwork.name); + setImmediate(done); + return subnetwork; + }; + + compute.getSubnetworks({}, assert.ifError); + }); + + it('should build a nextQuery if necessary', function(done) { + var apiResponseWithNextPageToken = extend({}, apiResponse, { + nextPageToken: 'next-page-token' + }); + + var query = { a: 'b', c: 'd' }; + var originalQuery = extend({}, query); + + compute.request = function(reqOpts, callback) { + callback(null, apiResponseWithNextPageToken); + }; + + compute.getSubnetworks(query, function(err, subnetworks, nextQuery) { + assert.ifError(err); + + assert.deepEqual(query, originalQuery); + + assert.deepEqual(nextQuery, extend({}, query, { + pageToken: apiResponseWithNextPageToken.nextPageToken + })); + + done(); + }); + }); + }); + }); + describe('getFirewalls', function() { it('should accept only a callback', function(done) { compute.request = function(reqOpts) { diff --git a/test/compute/network.js b/test/compute/network.js index fcc40e55411..5d023ff8d70 100644 --- a/test/compute/network.js +++ b/test/compute/network.js @@ -146,6 +146,26 @@ describe('Network', function() { }); }); + describe('createSubnetwork', function() { + it('should make the correct call to Region', function(done) { + var name = 'subnetwork-name'; + var config = { a: 'b', c: 'd', region: 'region1'}; + var expectedConfig = extend({}, config, { + network: network.formattedName, + name: name + }); + delete expectedConfig.region; + + network.compute.request = function(config_) { + assert.strictEqual(config_.json.name, name); + assert.deepEqual(config_.json, expectedConfig); + done(); + }; + + network.createSubnetwork(name, config, done); + }); + }); + describe('delete', function() { it('should call ServiceObject.delete', function(done) { FakeServiceObject.prototype.delete = function() { @@ -235,6 +255,52 @@ describe('Network', function() { }); }); + describe('getSubnetworks', function() { + it('should make the correct call to Compute', function(done) { + var options = { a: 'b', c: 'd' }; + var expectedOptions = extend({}, options, { + filter: 'network eq .*' + network.formattedName + }); + + network.compute.getSubnetworks = function(options, callback) { + assert.deepEqual(options, expectedOptions); + callback(); + }; + + network.getSubnetworks(options, done); + }); + + it('should not require options', function(done) { + network.compute.getSubnetworks = function(options, callback) { + callback(); + }; + + network.getSubnetworks(done); + }); + + it('should not require any arguments', function(done) { + network.compute.getSubnetworks = function(options, callback) { + assert.deepEqual(options, { + filter: 'network eq .*' + network.formattedName + }); + assert.strictEqual(typeof callback, 'undefined'); + done(); + }; + + network.getSubnetworks(); + }); + + it('should return the result of calling Compute', function() { + var resultOfgetSubnetworks = {}; + + network.compute.getSubnetworks = function() { + return resultOfgetSubnetworks; + }; + + assert.strictEqual(network.getSubnetworks(), resultOfgetSubnetworks); + }); + }); + describe('getFirewalls', function() { it('should make the correct call to Compute', function(done) { var options = { a: 'b', c: 'd' }; diff --git a/test/compute/region.js b/test/compute/region.js index cb4730dd442..366122e4467 100644 --- a/test/compute/region.js +++ b/test/compute/region.js @@ -37,6 +37,10 @@ function FakeRule() { this.calledWith_ = [].slice.call(arguments); } +function FakeSubnetwork() { + this.calledWith_ = [].slice.call(arguments); +} + function FakeServiceObject() { this.calledWith_ = arguments; ServiceObject.apply(this, arguments); @@ -54,7 +58,8 @@ var fakeStreamRouter = { extended = true; methods = arrify(methods); assert.equal(Class.name, 'Region'); - assert.deepEqual(methods, ['getAddresses', 'getOperations', 'getRules']); + assert.deepEqual(methods, + ['getAddresses', 'getOperations', 'getRules', 'getSubnetworks']); } }; @@ -76,6 +81,7 @@ describe('Region', function() { mockery.registerMock('../../lib/compute/address.js', FakeAddress); mockery.registerMock('../../lib/compute/operation.js', FakeOperation); mockery.registerMock('../../lib/compute/rule.js', FakeRule); + mockery.registerMock('../../lib/compute/subnetwork.js', FakeSubnetwork); mockery.enable({ useCleanCache: true, @@ -264,6 +270,97 @@ describe('Region', function() { }); }); + describe('createSubnetwork', function() { + var NAME = 'subnetwork-name'; + var OPTIONS = { a: 'b', c: 'd' }; + var EXPECTED_BODY = extend({}, OPTIONS, { name: NAME }); + + it('should not require any options', function(done) { + var expectedBody = { name: NAME }; + + region.request = function(reqOpts) { + assert.deepEqual(reqOpts.json, expectedBody); + done(); + }; + + region.createSubnetwork(NAME, assert.ifError); + }); + + it('should make the correct API request', function(done) { + region.request = function(reqOpts) { + assert.strictEqual(reqOpts.method, 'POST'); + assert.strictEqual(reqOpts.uri, '/subnetworks'); + assert.deepEqual(reqOpts.json, EXPECTED_BODY); + + done(); + }; + + region.createSubnetwork(NAME, OPTIONS, assert.ifError); + }); + + describe('error', function() { + var error = new Error('Error.'); + var apiResponse = { a: 'b', c: 'd' }; + + beforeEach(function() { + region.request = function(reqOpts, callback) { + callback(error, apiResponse); + }; + }); + + it('should execute callback with error & API response', function(done) { + region.createSubnetwork(NAME, OPTIONS, + function(err, subnetwork_, op, resp) { + assert.strictEqual(err, error); + assert.strictEqual(subnetwork_, null); + assert.strictEqual(op, null); + assert.strictEqual(resp, apiResponse); + done(); + }); + }); + }); + + describe('success', function() { + var apiResponse = { name: 'operation-name' }; + + beforeEach(function() { + region.request = function(reqOpts, callback) { + callback(null, apiResponse); + }; + }); + + it('should exec callback with Subnetwork, Op & apiResponse', + function(done) { + var subnetwork = {}; + var operation = {}; + + region.subnetwork = function(name) { + assert.strictEqual(name, NAME); + return subnetwork; + }; + + region.operation = function(name) { + assert.strictEqual(name, apiResponse.name); + return operation; + }; + + region.createSubnetwork(NAME, OPTIONS, + function(err, subnetwork_, op, resp) { + assert.ifError(err); + + assert.strictEqual(subnetwork_, subnetwork); + + assert.strictEqual(op, operation); + assert.strictEqual(op.metadata, resp); + + assert.strictEqual(resp, apiResponse); + done(); + }); + }); + }); + }); + + describe('getAddresses', function() { it('should accept only a callback', function(done) { region.request = function(reqOpts) { @@ -365,6 +462,109 @@ describe('Region', function() { }); }); + describe('getSubnetworks', function() { + it('should accept only a callback', function(done) { + region.request = function(reqOpts) { + assert.deepEqual(reqOpts.qs, {}); + done(); + }; + + region.getSubnetworks(assert.ifError); + }); + + it('should make the correct API request', function(done) { + var query = { a: 'b', c: 'd' }; + + region.request = function(reqOpts) { + assert.strictEqual(reqOpts.uri, '/subnetworks'); + assert.strictEqual(reqOpts.qs, query); + + done(); + }; + + region.getSubnetworks(query, assert.ifError); + }); + + describe('error', function() { + var error = new Error('Error.'); + var apiResponse = { a: 'b', c: 'd' }; + + beforeEach(function() { + region.request = function(reqOpts, callback) { + callback(error, apiResponse); + }; + }); + + it('should execute callback with error & API response', function(done) { + region.getSubnetworks({}, + function(err, subnetworks, nextQuery, apiResp) { + assert.strictEqual(err, error); + assert.strictEqual(subnetworks, null); + assert.strictEqual(nextQuery, null); + assert.strictEqual(apiResp, apiResponse); + done(); + }); + }); + }); + + describe('success', function() { + var apiResponse = { + items: [ + { name: 'operation-name' } + ] + }; + + beforeEach(function() { + region.request = function(reqOpts, callback) { + callback(null, apiResponse); + }; + }); + + it('should build a nextQuery if necessary', function(done) { + var nextPageToken = 'next-page-token'; + var apiResponseWithNextPageToken = extend({}, apiResponse, { + nextPageToken: nextPageToken + }); + var expectedNextQuery = { + pageToken: nextPageToken + }; + + region.request = function(reqOpts, callback) { + callback(null, apiResponseWithNextPageToken); + }; + + region.getSubnetworks({}, function(err, subnetworks, nextQuery) { + assert.ifError(err); + + assert.deepEqual(nextQuery, expectedNextQuery); + + done(); + }); + }); + + it('should execute callback with Operations & API resp', function(done) { + var subnetwork = {}; + + region.subnetwork = function(name) { + assert.strictEqual(name, apiResponse.items[0].name); + return subnetwork; + }; + + region.getSubnetworks({}, + function(err, subnetworks, nextQuery, apiResp) { + assert.ifError(err); + + assert.strictEqual(subnetworks[0], subnetwork); + assert.strictEqual(subnetworks[0].metadata, apiResponse.items[0]); + + assert.strictEqual(apiResp, apiResponse); + + done(); + }); + }); + }); + }); + describe('getOperations', function() { it('should accept only a callback', function(done) { region.request = function(reqOpts) { @@ -567,6 +767,17 @@ describe('Region', function() { }); }); + describe('subnetwork', function() { + var NAME = 'subnetwork-name'; + + it('should return a Subnetwork object', function() { + var subnetwork = region.subnetwork(NAME); + assert(subnetwork instanceof FakeSubnetwork); + assert.strictEqual(subnetwork.calledWith_[0], region); + assert.strictEqual(subnetwork.calledWith_[1], NAME); + }); + }); + describe('operation', function() { var NAME = 'operation-name'; diff --git a/test/compute/subnetwork.js b/test/compute/subnetwork.js new file mode 100644 index 00000000000..6fc2df1dea5 --- /dev/null +++ b/test/compute/subnetwork.js @@ -0,0 +1,186 @@ +/** + * Copyright 2015 Google Inc. All Rights Reserved. + * + * 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 assert = require('assert'); +var extend = require('extend'); +var format = require('string-format-obj'); +var mockery = require('mockery-next'); +var nodeutil = require('util'); + +var ServiceObject = require('../../lib/common/service-object.js'); +var util = require('../../lib/common/util.js'); + +function FakeServiceObject() { + this.calledWith_ = arguments; + ServiceObject.apply(this, arguments); +} + +nodeutil.inherits(FakeServiceObject, ServiceObject); + +describe('Subnetwork', function() { + var Subnetwork; + var subnetwork; + + var SUBNETWORK_NAME = 'subnetwork_name'; + var REGION_NAME = 'region-1'; + var REGION = { + createSubnetwork: util.noop, + name: REGION_NAME + }; + var SUBNETWORK_FULL_NAME = format('regions/{region}/subnetworks/{name}', { + region: REGION_NAME, + name: SUBNETWORK_NAME + }); + + before(function() { + mockery.registerMock( + '../../lib/common/service-object.js', + FakeServiceObject + ); + mockery.enable({ + useCleanCache: true, + warnOnUnregistered: false + }); + + Subnetwork = require('../../lib/compute/subnetwork.js'); + }); + + after(function() { + mockery.deregisterAll(); + mockery.disable(); + }); + + beforeEach(function() { + subnetwork = new Subnetwork(REGION, SUBNETWORK_NAME); + }); + + describe('instantiation', function() { + it('should localize the region', function() { + assert.strictEqual(subnetwork.region, REGION); + }); + + it('should localize the name', function() { + assert.strictEqual(subnetwork.name, SUBNETWORK_NAME); + }); + + it('should inherit from ServiceObject', function(done) { + var regionInstance = extend({}, REGION, { + createSubnetwork: { + bind: function(context) { + assert.strictEqual(context, regionInstance); + done(); + } + } + }); + + var subnetwork = new Subnetwork(regionInstance, SUBNETWORK_NAME); + assert(subnetwork instanceof ServiceObject); + + var calledWith = subnetwork.calledWith_[0]; + + assert.strictEqual(calledWith.parent, regionInstance); + assert.strictEqual(calledWith.baseUrl, '/subnetworks'); + assert.strictEqual(calledWith.id, SUBNETWORK_NAME); + assert.deepEqual(calledWith.methods, { + create: true, + exists: true, + get: true, + getMetadata: true + }); + }); + }); + + describe('formatName_', function() { + it('should format the name', function() { + var formattedName_ = Subnetwork.formatName_(REGION, SUBNETWORK_NAME); + assert.strictEqual(formattedName_, SUBNETWORK_FULL_NAME); + }); + }); + + describe('delete', function() { + it('should make the correct API request', function(done) { + subnetwork.request = function(reqOpts) { + assert.strictEqual(reqOpts.method, 'DELETE'); + assert.strictEqual(reqOpts.uri, ''); + done(); + }; + + subnetwork.delete(assert.ifError); + }); + + describe('error', function() { + var error = new Error('Error.'); + var apiResponse = { a: 'b', c: 'd' }; + + beforeEach(function() { + subnetwork.request = function(reqOpts, callback) { + callback(error, apiResponse); + }; + }); + + it('should return an error if the request fails', function(done) { + subnetwork.delete(function(err, operation, apiResponse_) { + assert.strictEqual(err, error); + assert.strictEqual(operation, null); + assert.strictEqual(apiResponse_, apiResponse); + done(); + }); + }); + + it('should not require a callback', function() { + assert.doesNotThrow(function() { + subnetwork.delete(); + }); + }); + }); + + describe('success', function() { + var apiResponse = { + name: 'op-name' + }; + + beforeEach(function() { + subnetwork.request = function(reqOpts, callback) { + callback(null, apiResponse); + }; + }); + + it('should execute callback with Operation & Response', function(done) { + var operation = {}; + + subnetwork.region.operation = function(name) { + assert.strictEqual(name, apiResponse.name); + return operation; + }; + + subnetwork.delete(function(err, operation_, apiResponse_) { + assert.ifError(err); + assert.strictEqual(operation_, operation); + assert.strictEqual(apiResponse_, apiResponse); + done(); + }); + }); + + it('should not require a callback', function() { + assert.doesNotThrow(function() { + subnetwork.delete(); + }); + }); + }); + }); +});