ns_connector 0.0.6

data/scripts/run_restlet

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+$: << File.join(
+	File.dirname(__FILE__),
+	'..', 'lib'
+)
+
+require 'ns_connector'
+require 'pp'
+
+unless ARGV.size == 2 then
+	warn(
+		"Usage: #{$0}"\
+		"<configuration as ruby code> "\
+		"<arguments as ruby code>"
+	)
+	warn('e.g.')
+	warn(
+		"#{$0}"\
+		'"{:account_id => ...}" "{:action => ...}"'
+	)
+	exit 1
+end
+
+NSConnector::Config.set_config!(eval(ARGV[0]))
+pp NSConnector::Restlet.execute!(eval(ARGV[1]))

data/scripts/test_shell

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+$: << File.join(
+	File.dirname(__FILE__),
+	'..', 'lib'
+)
+
+require 'ns_connector'
+require 'pry'
+
+if ARGV.empty? then
+	warn(
+		"Usage: #{$0}"\
+		"<configuration as ruby code>"
+	)
+	exit 1
+end
+
+
+
+NSConnector::Config.set_config!(eval(ARGV[0]))
+NSConnector.pry

data/spec/attaching_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class MagicResource 
+	extend NSConnector::Attaching 
+	def initialize upstream_store
+	end
+	def self.type_id
+		'magic'
+	end
+end
+
+class MagicTarget 
+	extend NSConnector::Attaching
+	def initialize upstream_store
+	end
+	def self.type_id
+		'target'
+	end
+end
+
+describe NSConnector::Attaching do
+	it 'attach! works' do
+		NSConnector::Restlet.should_receive(:execute!).with({
+			:action => 'attach',
+			:type_id => 'magic',
+			:target_type_id => 'target',
+			:attachee_id => 42,
+			:data => [1,2,3],
+			:attributes => nil,
+		})
+
+		MagicResource.attach!(MagicTarget, 42, [1,2,3])
+	end
+
+
+	it 'detach! works' do
+		NSConnector::Restlet.should_receive(:execute!).with({
+			:action => 'detach',
+			:type_id => 'magic',
+			:target_type_id => 'target',
+			:attachee_id => 42,
+			:data => [1,2,3]
+		})
+
+		MagicResource.detach!(MagicTarget, 42, [1,2,3])
+	end
+end
+

data/spec/chunked_searching_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class MagicResource 
+	extend NSConnector::ChunkedSearching
+	def initialize upstream_store
+	end
+	def self.type_id
+		'magic'
+	end
+end
+
+describe NSConnector::ChunkedSearching do
+	before :all do
+		# Keep things exciting
+		NSConnector::Config[:no_threads] = rand(15) + 1
+	end
+
+	def mock_chunked_search
+		(0..5).each do |i|
+			MagicResource.should_receive(:grab_chunk).
+				with('filters', i).ordered.and_return([1,2,3])
+		end
+
+		MagicResource.should_receive(:grab_chunk).
+			with('filters', 6).ordered.
+			and_raise(NSConnector::Errors::EndChunking, double)
+	end
+
+	it 'grabs a single chunk' do
+		NSConnector::Restlet.should_receive(:execute!).
+			with({
+				:action => 'search', 
+				:type_id => 'magic',
+				:data => {
+					:filters => 'filters',
+					:chunk => 42
+				}
+			}).and_return(['retval'])
+
+		MagicResource.should_receive(:new).with('retval')
+		expect(MagicResource.grab_chunk('filters', 42)).to be_a(Array)
+	end
+
+	it 'listens to the config' do
+		MagicResource.should_receive(:threaded_search_by_chunks).
+			with('filters').ordered.
+			and_return(1)
+		MagicResource.should_receive(:normal_search_by_chunks).
+			with('filters').ordered.
+			and_return(2)
+
+		expect(MagicResource.search_by_chunks('filters')).to eql(1)
+		NSConnector::Config[:use_threads] = false
+		expect(MagicResource.search_by_chunks('filters')).to eql(2)
+	end
+
+	it 'does a normal search correctly' do
+		mock_chunked_search
+
+		ret = MagicResource.normal_search_by_chunks('filters')
+
+		expect(ret).to be_a(Array)
+		# 5 iterations returning 3 each
+		expect(ret).to have(6 * 3).things
+	end
+
+	it 'does a threaded search correctly' do
+		mock_chunked_search
+
+		ret = MagicResource.threaded_search_by_chunks('filters')
+		expect(ret).to be_a(Array)
+		expect(ret).to have(6 * 3).things
+	end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+describe NSConnector::Config do
+	before(:each) do
+		# Reset our 'global' config
+		# Yes, it's kinda not nice to have a global configuration like
+		# this, but it's better than passing the damned thing around
+		# everywhere. Thread safety should be fine for reads.
+		NSConnector::Config.set_config!({})
+	end
+
+	it 'sets a valid config' do
+		NSConnector::Config.set_config!(valid_config)
+		expect(NSConnector::Config.check_valid!).to be_true
+	end
+
+	it 'sets an invalid config' do
+		NSConnector::Config.set_config!(:invalid => true)
+		expect{NSConnector::Config.check_valid!}.to raise_error
+	end
+
+	it 'allows reading of keys' do
+		expect(NSConnector::Config[:account_id]).to be_nil
+
+		NSConnector::Config.set_config!(valid_config)
+
+		expect(NSConnector::Config[:account_id]).to eql('account_id')
+		expect(NSConnector::Config['account_id']).to eql('account_id')
+	end
+
+	it 'allows writing of keys' do
+		expect(NSConnector::Config[:account_id]).to be_nil
+		NSConnector::Config[:account_id] = 'account_id'
+		expect(NSConnector::Config[:account_id]).to eql('account_id')
+
+		NSConnector::Config['account_id'] = nil
+		expect(NSConnector::Config[:account_id]).to be_nil
+	end
+
+	it 'has defaults' do
+		expect(NSConnector::Config['use_threads']).
+			to eql(!!NSConnector::Config['use_threads'])
+	end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+include NSConnector
+
+class PseudoResource < Resource
+	# The NetSuite internal id for the object. For a Contact, it would be
+	# 'contact'
+	@type_id = 'pseudoresource'
+	@fields = ['id', 'firstname', 'lastname']
+	@sublists = {:notes => [:line]}
+end
+
+# We create another resource here to ensure no clashes in anything shared.
+class OtherResource < Resource
+	@type_id = 'otherresource'
+	@fields = ['id', 'fax']
+	@sublists = {}
+end
+
+
+describe PseudoResource do
+	before :each do
+		@p = PseudoResource.new
+	end
+
+	context '#new' do
+		it 'has things we expect' do
+			PseudoResource.type_id.should eql('pseudoresource')
+			PseudoResource.fields.should eql(
+				['id', 'firstname', 'lastname']
+			)
+			PseudoResource.sublists.should eql({:notes => [:line]})
+		end
+
+		it 'automatically loads field ids just once on #new' do
+			PseudoResource.new
+			expect(@p.fields).
+				to eql(['id', 'firstname', 'lastname'])
+
+			OtherResource.new
+			o = OtherResource.new
+			expect(o.fields).to eql(['id', 'fax'])
+		end
+
+		it 'allows us to pass stuff to new' do
+			new_resource = PseudoResource.new(:firstname => 'first')
+			expect(new_resource.firstname).to eql('first')
+			expect(new_resource.lastname).to be_nil
+			expect(new_resource).to_not be_in_netsuite
+
+			in_ns_resource = PseudoResource.new(
+				{:lastname => 'last'}, true
+			)
+			expect(in_ns_resource.lastname).to eql('last')
+			expect(in_ns_resource.firstname).to be_nil
+			expect(in_ns_resource).to be_in_netsuite
+		end
+
+		it 'allows fields to be read and set' do
+			expect(@p.id).to be_nil
+			expect(@p.firstname).to be_nil
+			expect(@p.lastname).to be_nil
+
+			@p.firstname = 'first'
+			expect(@p.firstname).to eql('first')
+			expect(@p.store).to eql({'firstname' => 'first'})
+
+			# Ensure there is no odd behaviour here
+			p2 = PseudoResource.new
+			p2.firstname = 'second'
+
+			expect(@p.firstname).to eql('first')
+			expect(p2.firstname).to eql('second')
+		end
+
+		it 'does not exist in netsuite as it is new' do
+			expect(PseudoResource.new).to_not be_in_netsuite
+		end
+
+		it 'saves as a new object when #save! is called' do
+			ns_reply = {
+				'firstname' => 'Name',
+				'lastname' => 'nothing',
+				'id' => '42'
+			}
+
+			@p.firstname = 'name'
+
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'create',
+					:type_id => 'pseudoresource',
+					:fields => ['id', 'firstname', 'lastname'],
+					:data => {'firstname' => 'name'}
+				}).
+				once.
+				and_return(ns_reply)
+
+			expect(@p.save!).to eql(true)
+
+			expect(@p.firstname).to eql('Name')
+			expect(@p.lastname).to eql('nothing')
+			expect(@p.id).to eql('42')
+		end
+
+		it 'has a pretty inspect' do
+			expect(@p.inspect).to eql(
+				'#<NSConnector::PseudoResource:nil>'
+			)
+
+			@p.instance_variable_set('@store', {'id' => 1})
+			expect(@p.inspect).to eql(
+				'#<NSConnector::PseudoResource:1>'
+			)
+		end
+	end
+
+	context 'reading' do
+		it 'retrieves one resource with #find' do
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'retrieve',
+					:type_id => 'pseudoresource',
+					:fields => [
+						'id',
+						'firstname',
+						'lastname'
+					],
+					:data => {'id' => 42}
+				}).and_return({'firstname' => 'dude man'})
+
+			result = PseudoResource.find(42)
+			expect(result).to be_a(PseudoResource)
+			expect(result.firstname).to eql('dude man')
+			expect(result).to be_in_netsuite
+		end
+
+		it 'retrieves multiple resources with #advanced_search' do
+			expected_filters = [
+				['entityId', nil, 'is', '42'],
+				['email', nil, 'isempty']
+			]
+
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'search',
+					:type_id => 'pseudoresource',
+					:fields => [
+						'id',
+						'firstname',
+						'lastname'
+					],
+					:data => {:filters => expected_filters}
+				}).and_return([
+					{'id' => 1, 'firstname' => 'unique'},
+					{'id' => 2, 'firstname' => 'two'}
+				])
+
+			result = PseudoResource.advanced_search([
+				['entityId', nil, 'is', '42'],
+				['email', nil, 'isempty']
+			])
+			expect(result).to be_a(Array)
+			expect(result).to have(2).things
+
+			expect(result.first).to be_a(PseudoResource)
+			expect(result.first.firstname).to eql('unique')
+			expect(result.first.id).to eql(1)
+			expect(result.first).to be_in_netsuite
+
+			expect(result.last.firstname).to eql('two')
+		end
+
+		it 'has convenience method #search_by' do
+			PseudoResource.
+				should_receive(:advanced_search).
+				with([['a', nil, 'is', 'b']]).
+				and_return('nothing')
+			expect(PseudoResource.search_by('a', 'b')).
+				to eql('nothing')
+		end
+
+		it 'has convenience method #all' do
+			PseudoResource.
+				should_receive(:advanced_search).
+				with([]).
+				and_return('nothing')
+			expect(PseudoResource.all).to eql('nothing')
+		end
+
+		it 'tries to chunk given BeginChunking' do
+			Restlet.should_receive(:execute!).
+				and_raise(Errors::BeginChunking, double)
+			PseudoResource.should_receive(:search_by_chunks).
+				and_return('hai')
+			expect(PseudoResource.all).to eql('hai')
+		end
+	end
+
+	shared_context 'found_resource' do
+		before :each do
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'retrieve',
+					:type_id => 'pseudoresource',
+					:fields => [
+						'id',
+						'firstname',
+						'lastname'
+					],
+					:data => {'id' => 42}
+				}).and_return(
+					{
+						'id' => '1',
+						'firstname' => 'orig',
+						'lastname' => 'orig'
+					}
+				)
+			@found_resource = PseudoResource.find(42)
+			expect(@found_resource.firstname).to eql('orig')
+			expect(@found_resource).to be_in_netsuite
+		end
+	end
+
+	context 'updating' do
+		include_context 'found_resource'
+
+		it 'updates existing record in NetSuite' do
+			@found_resource.firstname = 'new'
+			expect(@found_resource.firstname).to eql('new')
+
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'update',
+					:type_id => 'pseudoresource',
+					:fields => [
+						'id',
+						'firstname',
+						'lastname'
+					],
+					:data => {
+						'firstname' => 'new',
+						'lastname' => 'orig',
+						'id' => '1'
+					}
+				}).
+				once.
+				and_return({'firstname' => 'New'})
+
+			@found_resource.save!
+
+			expect(@found_resource.lastname).to be_nil
+			expect(@found_resource.firstname).to eql('New')
+		end
+	end
+
+	context 'deleting' do
+		include_context 'found_resource'
+
+		it 'tries to delete ID via class method' do
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'delete',
+					:type_id => 'pseudoresource',
+					:data => {
+						'id' => 42
+					}
+				}).
+				once.and_return([])
+			PseudoResource.delete!(42)
+		end
+
+		it 'tries to delete ID via instance method' do
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'delete',
+					:type_id => 'pseudoresource',
+					:data => {
+						'id' => 1
+					}
+				}).
+				once.and_return([])
+			@found_resource.delete!
+		end
+
+		it 'returns false trying to delete an object not in NS' do
+			expect(@p.delete!).to be_false
+		end
+	end
+
+	context 'sublists on new object' do
+		it 'is empty' do
+			p = PseudoResource.new
+			expect(p.notes).to be_empty
+		end
+	end
+
+	context 'raw search' do
+		it 'has #raw_search' do
+			Restlet.should_receive(:execute!).
+				with({
+					:action => 'raw_search',
+					:type_id => 'pseudoresource',
+					:fields => [
+						'id', 'firstname', 'lastname'
+					],
+					:data => {
+						:columns => [['a']],
+						:filters => [['b']]
+					}
+				}).
+				once.and_return(['hai'])
+			expect(PseudoResource.raw_search([['a']], [['b']])).
+			       to eql(['hai'])
+		end
+	end
+
+	context 'link aliases' do
+		include_context 'found_resource'
+
+		it 'has #link' do
+			PseudoResource.should_receive(:attach!).
+				with(OtherResource, '1', [1,2], nil)
+			@found_resource.attach!(OtherResource, [1,2])
+
+			expect{@p.attach!(OtherResource, [1,2])}.to raise_error(
+				::ArgumentError, /need an id/i
+			)
+		end
+
+		it 'has #unlink' do
+			PseudoResource.should_receive(:detach!).
+				with(OtherResource, '1', [1,2])
+			@found_resource.detach!(OtherResource, [1,2])
+
+			expect{@p.detach!(OtherResource, [1,2])}.to raise_error(
+				::ArgumentError, /need an id/i
+			)
+		end
+	end
+end