ns_connector 0.0.6

data/spec/resources/contact_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+include NSConnector
+describe Contact do
+	it 'should not explode on creation' do
+		Contact.new
+	end
+end

data/spec/resources/customer_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+include NSConnector
+describe Customer do
+	it 'should not explode on creation' do
+		Customer.new
+	end
+end

data/spec/resources/invoice_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+include NSConnector
+describe Invoice do
+	it 'should not explode on creation' do
+		Invoice.new
+	end
+	
+	it 'should have a to_pdf method' do
+		Restlet.should_receive(:execute!).and_return(
+			[Base64::encode64('yay')]
+		)
+		expect{Invoice.new.to_pdf}.to raise_error(
+			::ArgumentError,
+			/could not find id/i
+		)
+		expect(Invoice.new(:id => 1).to_pdf).to eql('yay')
+	end
+end
+

data/spec/restlet_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+include NSConnector
+
+describe Restlet do
+	context 'given a valid config' do
+		before(:each) do
+			NSConnector::Config.set_config! valid_config
+		end
+
+		it 'executes a restlet, passing the options' do
+			options = {:opt1 => 'value1', :opt2 => 'value2'}
+			expected_body = options.merge(
+				:code => Restlet.restlet_code
+			).to_json
+
+			# We already test the auth header below. We simply test
+			# its existance here.
+			expected_request = {
+				:body => expected_body,
+				:headers => {
+					'Authorization' => /^NLAuth/,
+					'Content-Type'=>'application/json'
+				}
+			}
+
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				with(expected_request).
+				to_return(
+					:status => 200,
+					:body => '["json"]',
+			)
+			expect(Restlet.execute!(options)).to eql(['json'])
+		end
+
+		it 'fails gracefully with 500' do
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 500, :body => 'message')
+			expect{Restlet.execute!({})}.to raise_error(
+				Restlet::RuntimeError,
+				/500: message/
+			)
+		end
+
+		it 'tries to create a nice error from a 400' do
+			# Acutal netsuite responses as of 7 Jun 13
+			#
+			# RCRD_DSNT_EXIST -> NotFound
+			error = '{"error" : {"code" : "RCRD_DSNT_EXIST", '\
+				'"message" : "That record does not exist."}}'
+
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 400, :body => error)
+			expect{Restlet.execute!({})}.to raise_error(
+				Errors::NotFound, /does not exist/
+			)
+
+			# ANYTHING represents 'CONTACT' or 'CUSTOMER', or
+			# Whatever
+			#
+			# ANYTHING_ALREADY_EXISTS -> Conflict
+			error = '{"error" : {"code" : '\
+			'"ANYTHING_ALREADY_EXISTS", '\
+			'"message" : "A contact record with this name '\
+			'already exists. Every contact record must have '\
+			'a unique name."}}'
+
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 400, :body => error)
+			expect{Restlet.execute!({})}.to raise_error(
+				Errors::Conflict, /A contact record/
+			)
+		end
+
+		it 'creates a Unknown error from parseable but unknown JSON' do
+			error = '{"error" : {"code" : "GREEN_ROOM", '\
+				'"message" : "This room is... Green."}}'
+
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 400, :body => error)
+			expect{Restlet.execute!({})}.to raise_error(
+				Errors::Unknown, /room is/
+			)
+		end
+
+		it 'creates a WTF error from unparseable JSON' do
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 400, :body => 'omgwtf')
+			expect{Restlet.execute!({})}.to raise_error(
+				Errors::WTF, /omgwtf/
+			)
+		end
+
+		it 'fails gracefully with bad JSON' do
+			stub_request(:post, "https://netsuite:1234/restlet?").
+				to_return(:status => 200, :body => 'omgwtf')
+			expect{Restlet.execute!({})}.to raise_error(
+				Restlet::RuntimeError,
+				/omgwtf.*unexpected token/
+			)
+		end
+
+
+		it 'generates a valid auth header' do
+			expect(Restlet.auth_header).to eql(
+				'NLAuth nlauth_account=account_id,' \
+				'nlauth_email=email@site,'          \
+				'nlauth_role=123,'                  \
+				'nlauth_signature=pass%00word'
+			)
+		end
+
+		it 'retrieves code' do
+			expect(Restlet.restlet_code).to be_a(String)
+			expect(Restlet.restlet_code).to_not be_empty
+		end
+	end
+
+	context 'given an invalid config' do
+		before(:each) do
+			NSConnector::Config.set_config!(:invalid => true)
+		end
+
+		it 'everything raises ArgumentError' do
+			expect{Restlet.execute!({})}.
+				to raise_error(
+					NSConnector::Config::ArgumentError
+				)
+
+			expect{Restlet.auth_header}.
+				to raise_error(
+					NSConnector::Config::ArgumentError
+				)
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.join(File.dirname(__FILE__))
+
+require 'pry'
+require 'pp'
+require 'rspec'
+require 'webmock/rspec'
+require 'ns_connector'
+
+require 'support/mock_data'
+
+RSpec.configure do |config|
+	config.order = "random"
+	config.color_enabled = true
+end
+

data/spec/sublist_item_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+include NSConnector
+
+describe SubListItem do
+	context 'new' do
+		before :each do
+			parent = double(
+				'contact', :type_id => 'contact', :id => '42'
+			)
+			@s = SubListItem.new('sublist', ['field1', 'field2'], parent)
+		end
+
+		it 'has things we expect' do
+			expect(@s.field1).to eql(nil)
+			@s.field1 = 'yay'
+			expect(@s.field1).to eql('yay')
+			expect(@s.field2).to eql(nil)
+		end
+
+		it 'has a .store' do
+			@s.field1 = 'yay'
+			expect(@s.store).to eql('field1' => 'yay')
+		end
+	end
+end

data/spec/sublist_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+include NSConnector
+
+describe SubList do
+	before :each do
+		@parent = double(
+			'contact', :type_id => 'contact', :id => '42'
+		)
+		@item1 = SubListItem.new(
+			'sublist', ['field1', 'field2'], @parent, 
+			:field1 => 'data'
+		)
+		@item2 = SubListItem.new(
+			'sublist', ['field1', 'field2'], @parent,
+			:field2 => 'otherdata'
+		)
+	end
+
+	it 'fetches' do
+		Restlet.should_receive(:execute!).
+			with({
+				:action => 'fetch_sublist',
+				:type_id => 'contact',
+				:parent_id => '42',
+				:sublist_id => 'sublist',
+				:fields => ['field1', 'field2'],
+			}).and_return(
+				[
+					{'field1' => 'new'},
+					{'field2' => 'new2'},
+				]
+			)
+		sublist = SubList.fetch(
+			@parent, 'sublist', ['field1', 'field2']
+		)
+
+		expect(sublist).to be_a(Array)
+		expect(sublist).to have(2).things
+		sublist.each do |item|
+			expect(item).to be_a(SubListItem)
+		end
+		expect(sublist.first.field1).to eql('new')
+		expect(sublist.last.field2).to eql('new2')
+	end
+end

data/spec/support/mock_data.rb

@@ -0,0 +1,10 @@
+# Valid configuration hash for NSConnector::Config
+def valid_config
+	{
+		:account_id  => 'account_id',
+		:email    => 'email@site',
+		:password    => "pass\0word",
+		:role        => '123',
+		:restlet_url => 'https://netsuite:1234/restlet',
+	}
+end

data/support/read_only_test

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+$: << File.join(
+		File.dirname(__FILE__),
+			'..', 'lib'
+)
+
+require 'ns_connector'
+require 'rspec/autorun'
+
+unless ARGV.size == 1 then
+	warn "Usage: #{$0} <config as ruby code>"
+	warn "Warning! This script could destroy production data, it is only"\
+		" intended for testing"
+end
+
+# We shift the argument off here, or it gets passed to the RSpec runner
+NSConnector::Config.set_config!(eval(ARGV.shift))
+
+def customer_id
+	NSConnector::Config[:valid_customer_id]
+end
+
+# This only theoretically a read only live conformance test, run at your own
+# peril! Seriously, if you run this on production data and the internet
+# explodes, well, you're stupid, unlucky, and I warned you.
+
+describe 'retrieve' do
+	it 'returns a Hash with an id' do
+		record = NSConnector::Restlet.execute!({
+			:action => 'retrieve',
+			:type_id => 'contact',
+			:fields => ['id', 'firstname', 'lastname'],
+			:data => {
+				:id => customer_id,
+			}
+		})
+
+		expect(record).to be_a(Hash)
+		expect(record['id']).to be_a(String)
+		expect(record.keys).to include('firstname')
+		expect(record.keys).to include('lastname')
+	end
+end
+
+describe 'search' do
+	it 'returns a basic search by id' do
+		record = NSConnector::Restlet.execute!(
+			:action => 'search',
+			:type_id => 'contact',
+			:fields => ['id'],
+			:data => {
+				:filters => [
+					['internalid', nil, 'is', customer_id]
+				]
+			}
+		)
+
+		expect(record).to be_a(Array)
+		expect(record).to_not be_empty
+		expect(record.first['id']).to be_a(String)
+		expect(record.first['id']).to_not be_empty
+	end
+end

data/support/restlet.js

@@ -0,0 +1,384 @@
+// How large a result set we try to return before splitting it up into smaller
+// chunks
+var CHUNK_SIZE = 100;
+
+// Okay, so this is some dodgy meta shit that I probably really shouldn't be
+// doing in javascript. It's not my fault the API is odd.
+function apply_constructor(klass, opts) {
+	function applicator() {
+		// This seems to be the only way to call .apply on a
+		// constructor in javascript
+		return klass.apply(this, opts);
+	}
+	applicator.prototype = klass.prototype;
+	return new applicator();
+}
+
+// Stops execution, sending a HTTP 400 response
+function argument_error(message)
+{
+	throw nlapiCreateError('400', message);
+}
+
+
+// Returns a simple record as an associative array
+function get_record_by_id(type_id, fields, id)
+{
+	var record = nlapiLoadRecord(type_id, id);
+	var response = {};
+
+	for(var i = 0; i < fields.length; i++ ) {
+		response[fields[i]] = record.getFieldValue(fields[i]);
+	}
+
+	return(response);
+}
+
+// In order to update an item, we create a diff of what has actually changed,
+// then commit just those changes.
+function update(request)
+{
+	if(!request.data.hasOwnProperty('id')) {
+		argument_error('update action requires an id');
+	}
+
+	var diff = {};
+	var record = nlapiLoadRecord(request.type_id, request.data.id);
+
+	for(var field in request.data) {
+		if(record.getFieldValue(field) != request.data[field]) {
+			diff[field] = request.data[field];
+		}
+	}
+
+	for(var field in diff) {
+		record.setFieldValue(field, diff[field]);
+	}
+
+	return(get_record_by_id(
+		request.type_id,
+		request.fields,
+		nlapiSubmitRecord(record, true)
+	));
+}
+
+// Return an array of hashes representing the result set.
+function retrieve_result_set(results, fields)
+{
+	var response = [];
+	// Can't seem to get all columns back without running nlapiLoadRecord,
+	// I tried a few different ways and netsuite either returned null
+	// responses or exploded spectacularly. So, we are inefficient for now.
+	//
+	// This is what has lead to the whole configurable chunking
+	// implementation.
+	for(var i = 0; i < results.length; i++ ) {
+		var result = results[i];
+		response.push(
+			get_record_by_id(
+				result.getRecordType(),
+				fields,
+				result.getId()
+			)
+		);
+	}
+
+	return response;
+}
+
+// Return the requested chunk offset, which should be incremented by one for
+// each chunk.
+function search_chunked(search, fields, chunk)
+{
+	var offset = chunk * CHUNK_SIZE;
+	var results = search.runSearch().getResults(offset, offset + CHUNK_SIZE);
+	if(results.length == 0) {
+		throw nlapiCreateError('400', 'NO_MORE_CHUNKS');
+	}
+	return(retrieve_result_set(results, fields));
+}
+
+// Called if we aren't specifically asking for a chunk of the result set.
+// Returns:: An array of records of length < CHUNK_SIZE
+// Raises:: A 400, 'CHUNKY_MONKEY' if the result size is >= CHUNK_SIZE, it is
+// 	expected that you now send a follow up request asking for chunks until
+// 	you recive another error, 'NO_MORE_CHUNKS'
+function search_no_chunked(search, fields)
+{
+	var results = search.runSearch().getResults(0, CHUNK_SIZE);
+
+	// If there are CHUNK_SIZE results, we need to chunk
+	if (results.length == CHUNK_SIZE) {
+		// So we send an error message to signify that the client
+		// should make a different kind of search request
+		throw nlapiCreateError('400', 'CHUNKY_MONKEY');
+	}
+
+	return(retrieve_result_set(results, fields));
+}
+
+// Only return the columns requested, not whole objects.
+// Returns:: Array of arrays containing all columns requested.
+function raw_search(request)
+{
+	var columns = [];
+	var filters = [];
+	var response = [];
+
+	// Generate filters
+	for(var i = 0; i < request.data.filters.length; i++ ) {
+		filters.push(
+			apply_constructor(
+				nlobjSearchFilter, request.data.filters[i]
+			)
+		);
+	}
+
+	// Doesn't work when we try to create columns then supply them at
+	// creation, so we create them after we create the search.
+	var search = nlapiCreateSearch(request.type_id, filters, []);
+
+	// Now, for whatever reason, we can add columns.
+	for(var i = 0; i < request.data.columns.length; i++ ) {
+		columns.push(apply_constructor(
+			nlobjSearchColumn, request.data.columns[i]
+		));
+		search.addColumn(columns[i]);
+	}
+
+	var search_result = search.runSearch();
+	// We go 1000 at a time as that is the maximum we are allowed
+	var MAX_PER_GET=1000;
+	for(var i = 0; true; i += MAX_PER_GET) {
+		var result_set = search_result.getResults(i, MAX_PER_GET);
+		for(var j = 0; j < result_set.length; j++) {
+			response.push([]);
+			for(var k = 0; k < columns.length; k++) {
+				response[j].push(
+					result_set[j].getValue(columns[k])
+				);
+			}
+		}
+		if(result_set.length < MAX_PER_GET) {
+			// No more results
+			break;
+		}
+	}
+
+	return(response);
+}
+
+function search(request)
+{
+	// Maximum results to return before we split our response into a
+	// chunked, multi request response. Note, this has nothing to do with a
+	// HTTP chunked response, it's simply us requesting a different offest
+	// each time.
+
+	var filters = [];
+	for(var i = 0; i < request.data.filters.length; i++ ) {
+		filters.push(
+			apply_constructor(
+				nlobjSearchFilter, request.data.filters[i]
+			)
+		);
+	}
+
+	var search = nlapiCreateSearch(request.type_id, filters, []);
+
+	if(request.data.hasOwnProperty('chunk')){
+		return(search_chunked(
+			search, request.fields, request.data.chunk
+		));
+	} else {
+		return search_no_chunked(search, request.fields);
+	}
+}
+
+// Retrieve a single record by id
+function retrieve(request)
+{
+	if(!request.data.hasOwnProperty('id')) {
+		argument_error('retrieve action requires an id');
+	}
+
+	return(get_record_by_id(
+		request.type_id, request.fields, request.data.id)
+	);
+}
+
+// Load a list of fields for type specified by type_id
+// Returns:: Array of strings
+// Delete a record by id
+function delete_id(request)
+{
+	if(!request.data.hasOwnProperty('id')) {
+		argument_error('delete action requires an id');
+	}
+
+	// Return value is moot, should throw an error on failure
+	nlapiDeleteRecord(request.type_id, parseInt(request.data.id));
+	return([]);
+}
+
+// Create a new record
+function create(request)
+{
+	var record = nlapiCreateRecord(request.type_id);
+	var response = {};
+
+	for(var field in request.data) {
+		record.setFieldValue(field, request.data[field]);
+	}
+
+	for(var i = 0; i < request.fields.length; i++ ) {
+		response[request.fields[i]] = record.getFieldValue(
+			request.fields[i]
+		);
+	}
+
+	return(get_record_by_id(
+		request.type_id,
+		request.fields,
+		nlapiSubmitRecord(record, true)
+	));
+}
+
+// Given a record, sublist_id and array of fields, retrieve the whole sublist
+// as an array of hashes 
+function get_sublist(record, sublist_id, fields)
+{
+	var len = record.getLineItemCount(request.sublist_id);
+	var response = [];
+	for(var i = 1; i <= len; i++) {
+		list_item = {};
+		for(var j = 0; j < fields.length; j++) {
+			list_item[fields[j]] = record.getLineItemValue(
+				sublist_id, fields[j], i
+			)
+		}
+		response.push(list_item);
+	}
+	return(response);
+}
+
+// Basically a wrapper for get_sublist()
+function fetch_sublist(request)
+{
+	if(!request.hasOwnProperty('parent_id')) {
+		argument_error("Missing mandatory argument: parent_id");
+	}
+
+	if(!request.hasOwnProperty('sublist_id')) {
+		argument_error("Missing mandatory argument: sublist_id");
+	}
+
+	var record = nlapiLoadRecord(request.type_id, request.parent_id);
+	return(get_sublist(record, request.sublist_id, request.fields));
+}
+
+// Make sure we have the required arguments in our request object
+function pre_flight_check(request)
+{
+	delete(request['code']);
+
+	if (!request.hasOwnProperty('action')) {
+		argument_error("Missing mandatory argument: action");
+	}
+
+	// Some actions may not care about these
+	if (!request.hasOwnProperty('fields')) {
+		request.fields = [];
+	}
+	if (!request.hasOwnProperty('sublists')) {
+		request.sublists = {};
+	}
+	if (!request.hasOwnProperty('data')) {
+		request.data = {};
+	}
+}
+
+// Render a PDF invoice
+//
+// Arguments::
+// 	invoice_id:: the ID of the invoice to render
+//
+// Returns:: An array with only element, a base64 encoded string of the
+// generated PDF
+function invoice_pdf(request) {
+	if(!request.hasOwnProperty('invoice_id')) {
+		argument_error('Missing mandatory argument: invoice_id');
+	};
+
+	var file = nlapiPrintRecord(
+		'TRANSACTION',
+		request.invoice_id,
+		'PDF',
+		null
+	);
+
+	return [file.getValue()];
+}
+
+// Attach all customers in data from ourselves
+// Arguments::
+// 	target_type_id:: target 'type_id'
+// 	attachee_id:: id of record type 'type_id' to attach from
+// 	data:: array of ids to attach
+// 	attributes:: optional attributes
+function attach(request) {
+	for(var i = 0; i < request.data.length; i++) {
+		nlapiAttachRecord(
+			request.type_id,
+			request.attachee_id,
+			request.target_type_id,
+			parseInt(request.data[i]),
+			request.attributes
+		);
+	}
+	return([]);
+}
+//
+// Detach all customers in data from ourselves
+// Arguments::
+// 	target_type_id:: target 'type_id'
+// 	attachee_id:: id of record type 'type_id' to detach from
+// 	data:: array of ids to attach
+// 	attributes:: optional attributes
+function detach(request) {
+	for(var i = 0; i < request.data.length; i++) {
+		nlapiDetachRecord(
+			request.type_id,
+			request.attachee_id,
+			request.target_type_id,
+			parseInt(request.data[i])
+		);
+	}
+	return([]);
+}
+
+// As the last visible function, this is the one actually run and the return
+// value is sent back to the client as JSON.
+function main(request)
+{
+	pre_flight_check(request);
+
+	var actions = {
+		'delete'        : delete_id, // delete is a reserved word
+		'create'        : create,
+		'retrieve'      : retrieve,
+		'search'        : search,
+		'update'        : update,
+		'fetch_sublist' : fetch_sublist,
+		'invoice_pdf'   : invoice_pdf,
+		'attach'   	: attach,
+		'detach'   	: detach,
+		'raw_search'   	: raw_search,
+	}
+
+	if(!(request.action in actions)) {
+		argument_error("Unknown action: " + request.action);
+	}
+
+	return actions[request.action](request);
+}