aye_commander 1.0.0

data/spec/aye_commander/errors_spec.rb

@@ -0,0 +1,25 @@
+describe AyeCommander::MissingRequiredArgumentError do
+  let(:error) { AyeCommander::MissingRequiredArgumentError }
+
+  it 'is an AyeCommander::Error child' do
+    expect(error.superclass).to be AyeCommander::Error
+  end
+
+  it 'should have a descriptive message of the error' do
+    errori = error.new [:taco]
+    expect(errori.message).to eq 'Missing required arguments: [:taco]'
+  end
+end
+
+describe AyeCommander::UnexpectedReceivedArgumentError do
+  let(:error) { AyeCommander::UnexpectedReceivedArgumentError }
+
+  it 'is an AyeCommander::Error child' do
+    expect(error.superclass).to be AyeCommander::Error
+  end
+
+  it 'should have a descriptive message of the error' do
+    errori = error.new [:taco]
+    expect(errori.message).to eq 'Received unexpected arguments: [:taco]'
+  end
+end

data/spec/aye_commander/hookable_spec.rb

@@ -0,0 +1,105 @@
+describe AyeCommander::Hookable::ClassMethods do
+  include_context :command
+
+  %i(before around after aborted).each do |kind|
+    context ".#{kind}" do
+      it "adds the args to the #{kind} hooks array" do
+        command.send kind, :some, :method
+        expect(command.send("#{kind}_hooks")).to eq [:some, :method]
+        expect(command.instance_variable_get(:@hooks)).to_not be_empty
+        expect(command.instance_variable_get(:@hooks).default).to be_empty
+      end
+
+      it 'adds the received block as a block, after the args' do
+        command.send(kind, :some) { :hello }
+        expect(command.send("#{kind}_hooks").count).to eq 2
+        expect(command.send("#{kind}_hooks").last).to be_instance_of Proc
+      end
+
+      it 'adds the args at the end of the array' do
+        command.send kind, :first
+        command.send kind, :second, :third
+        expect(command.send("#{kind}_hooks")).to eq [:first, :second, :third]
+      end
+
+      it 'adds the args at the beginning of the array with the prepend option' do
+        command.send kind, :first
+        command.send kind, :second, :third, prepend: true
+        expect(command.send("#{kind}_hooks")).to eq [:second, :third, :first]
+      end
+    end
+
+    context ".#{kind}_hooks" do
+      it 'returns empty array with nothing set' do
+        expect(command.send("#{kind}_hooks")).to eq []
+      end
+
+      it 'returns the array of hooks' do
+        command.instance_variable_set :@hooks, kind => [:hello]
+        expect(command.send("#{kind}_hooks")).to eq [:hello]
+      end
+    end
+  end
+
+  %i(before after aborted).each do |kind|
+    context ".call_#{kind}_hooks" do
+      before :each do
+        body = -> { success? }
+        command.send :define_method, :by_symbol, &body
+        command.send :define_method, :by_method, &body
+        command.send kind, :by_symbol, instance.method(:by_method), body, &body
+      end
+
+      it 'makes all supported hooks callable' do
+        expect(command.send("call_#{kind}_hooks", instance)).to all(respond_to :call)
+      end
+
+      it 'calls all the prepared hooks' do
+        hooks = command.send "call_#{kind}_hooks", instance
+        allow(command).to receive(:prepare_hooks).and_return(hooks)
+        expect(hooks).to all(receive(:call))
+        command.send "call_#{kind}_hooks", instance
+      end
+
+      it 'runs all the prepared hooks in the instance context' do
+        expect(instance).to receive(:success?).exactly(4).times
+        command.send "call_#{kind}_hooks", instance
+      end
+    end
+  end
+
+  context '.call_around_hooks' do
+    before :each do
+      body = lambda do |step|
+        @order ||= []
+        number = order.count + 1
+        @order << number
+
+        success?
+        step.call
+        failure?
+
+        @order << number
+      end
+
+      command.send :define_method, :by_symbol, &body
+      command.send :define_method, :by_method, &body
+      command.around :by_symbol, instance.method(:by_method), body, &body
+    end
+
+    it 'compacts everything into one proc' do
+      expect(command.call_around_hooks(instance).count).to eq 1
+    end
+
+    it 'calls everything' do
+      expect(instance).to receive(:success?).exactly(4).times
+      expect(instance).to receive(:failure?).exactly(4).times
+      command.call_around_hooks(instance)
+    end
+
+    it 'should call the hooks in the correct order' do
+      command.call_around_hooks(instance)
+      expect(instance.order).to eq [1, 2, 3, 4, 4, 3, 2, 1]
+    end
+  end
+end

data/spec/aye_commander/initializable_spec.rb

@@ -0,0 +1,33 @@
+describe AyeCommander::Initializable do
+  include_context :command
+
+  context '#initialize' do
+    it 'sets the instance variables with the received arguments' do
+      i = command.new(taco: :burrito, dogo: :hungry)
+      expect(i.taco).to eq :burrito
+      expect(i.dogo).to eq :hungry
+    end
+
+    it 'is able to handle the case when the variable start with @' do
+      i = command.new(:@taco => :burrito, :@dogo => :hungry)
+      expect(i.taco).to eq :burrito
+      expect(i.dogo).to eq :hungry
+    end
+
+    it 'is able to handle the case when no args are received' do
+      expect { command.new }.to_not raise_error
+    end
+
+    context 'when a command' do
+      it 'sets the status to :success if no other succeed has been set' do
+        command.succeeds_with :potato
+        expect(instance.status).to eq :success
+      end
+
+      it 'sets the status to the first suceed if success has been excluded' do
+        command.succeeds_with :potato, exclude_success: true
+        expect(instance.status).to eq :potato
+      end
+    end
+  end
+end

data/spec/aye_commander/inspectable_spec.rb

@@ -0,0 +1,45 @@
+describe AyeCommander::Inspectable do
+  include_context :command
+
+  before :each do
+    instance.instance_variable_set :@variable, :something
+    instance.instance_variable_set :@other, :potato
+  end
+
+  context '#inspect' do
+    it 'gives a string representation of the innards of the class' do
+      expect(instance.inspect).to match(/#<#<Class:\dx\w+> @status: success, @variable: something, @other: potato>/)
+    end
+  end
+
+  context '#to_hash' do
+    it 'gives a hash representation of the innards of the class' do
+      result = { :@status => :success, :@variable => :something, :@other => :potato }
+      expect(instance.to_hash).to eq result
+    end
+
+    it 'gives a hash representation of the innards of the class with the requested values' do
+      result = { :@variable => :something, :@other => :potato }
+      expect(instance.to_hash([:@variable, :other])).to eq result
+    end
+  end
+
+  context '#to_result_hash' do
+    it 'gives a hash of all values for the result if no return was specified' do
+      result = { :@status => :success, :@variable => :something, :@other => :potato }
+      expect(instance.to_result_hash).to eq result
+    end
+
+    it 'gives the necessary values for the result when a return was specified' do
+      command.returns :other
+      result = { :@status => :success, :@other => :potato }
+      expect(instance.to_result_hash).to eq result
+    end
+
+    it 'assigns nil to the values that were not created when a result was specified' do
+      command.returns :badger
+      result = { :@status => :success, :@badger => nil }
+      expect(instance.to_result_hash).to eq result
+    end
+  end
+end

data/spec/aye_commander/ivar_spec.rb

@@ -0,0 +1,130 @@
+describe AyeCommander::Ivar::ClassMethods do
+  include_context :command
+
+  context '.define_missing_reader' do
+    it 'calls uses if its a command' do
+      expect(command).to receive(:uses).with(:taco)
+      command.define_missing_reader(:taco)
+    end
+
+    it 'defines the attr_reader if its a result' do
+      command.result_class.define_missing_reader(:taco)
+      expect(result).to respond_to :taco
+      expect(result).to_not respond_to :taco=
+    end
+  end
+
+  context '.to_ivar' do
+    it 'returns itself when the name is already in ivar form' do
+      expect(command.to_ivar(:@var)).to eq :@var
+    end
+
+    it 'returns the ivar form when name is not in ivar form' do
+      expect(command.to_ivar(:var)).to eq :@var
+    end
+
+    it 'is able to handle strings' do
+      expect(command.to_ivar('@var')).to eq :@var
+      expect(command.to_ivar('var')).to  eq :@var
+    end
+  end
+
+  context '.to_nvar' do
+    it 'returns itself when name is already in nvar form' do
+      expect(command.to_nvar(:var)).to eq :var
+    end
+
+    it 'returns the nvar form when name is not in nvar form' do
+      expect(command.to_nvar(:@var)).to eq :var
+    end
+
+    it 'is able to handle strings' do
+      expect(command.to_nvar('@var')).to eq :var
+      expect(command.to_nvar('var')).to  eq :var
+    end
+  end
+end
+
+describe AyeCommander::Ivar::Readable do
+  include_context :command
+
+  context '#method_missing' do
+    it 'raises if asked a method without an instance variable defined' do
+      expect { instance.taco }.to raise_error NoMethodError
+    end
+
+    it 'responds if asked the name of an instance variable' do
+      instance.instance_variable_set :@taco, :badger
+      expect(instance.taco).to eq :badger
+    end
+
+    it 'calls .define_missing_reader' do
+      expect(command).to receive(:define_missing_reader).with(:taco)
+      instance.instance_variable_set :@taco, :badger
+      instance.taco
+    end
+  end
+
+  context '#remove!' do
+    it 'removes an instance variable' do
+      instance.remove!(:status)
+      expect(instance.instance_variables).to be_empty
+    end
+  end
+
+  context '#to_ivar' do
+    it 'calls the .to_ivar' do
+      instance
+      expect(command).to receive(:to_ivar).with(:var)
+      instance.to_ivar(:var)
+    end
+  end
+
+  context '#to_nvar' do
+    it 'calls the .to_nvar' do
+      expect(command).to receive(:to_nvar).with(:var)
+      instance.to_nvar(:var)
+    end
+  end
+
+  context 'p#respond_to_missing?' do
+    it 'returns true if the variable name is defined' do
+      instance.instance_variable_set :@taco, :badger
+      expect(instance.send(:respond_to_missing?, :taco, [false])).to be true
+    end
+
+    it 'uses super if the variable name is not defined' do
+      expect(instance.send(:respond_to_missing?, :taco, [false])).to be false
+    end
+
+    it 'uses super if the variable name is not valid' do
+      expect(instance.send(:respond_to_missing?, :taco!, [false])).to be false
+    end
+  end
+end
+
+describe AyeCommander::Ivar::Writeable do
+  include_context :command
+
+  context '#method_missing' do
+    it 'responds to equality assignments' do
+      expect { instance.taco = 1 }.to_not raise_error
+    end
+
+    it 'defines the method so next time it doesnt go through method_missing' do
+      instance.taco = 1
+      expect(instance).to respond_to :taco
+      expect(instance).to respond_to :taco=
+    end
+  end
+
+  context 'p#respond_to_missing?' do
+    it 'returns true if variable name ends with =' do
+      expect(instance.send(:respond_to_missing?, :taco=, [false])).to be true
+    end
+
+    it 'uses super otherwise' do
+      expect(instance.send(:respond_to_missing?, :taco, [false])).to be false
+    end
+  end
+end

data/spec/aye_commander/limitable_spec.rb

@@ -0,0 +1,131 @@
+describe AyeCommander::Limitable::ClassMethods do
+  include_context :command
+  let(:args)      { %i(arg1 arg2) }
+
+  context '.uses' do
+    it 'should call save_variable' do
+      command.uses(*args)
+      expect(command.uses).to eq args
+    end
+
+    it 'should create accessors for the received values' do
+      command.uses(*args)
+      args.each do |arg|
+        expect(instance).to respond_to arg
+        expect(instance).to respond_to "#{arg}="
+      end
+    end
+  end
+
+  %i(receives requires returns).each do |limiter|
+    context ".#{limiter}" do
+      before :each do
+        command.public_send limiter, *args
+      end
+
+      it 'should call .uses' do
+        expect(command).to receive(:uses).with(*args).and_return(true)
+        command.public_send limiter, *args
+      end
+
+      it 'should save the values to a class instance variable' do
+        expect(command.limiters[limiter]).to eq args
+      end
+
+      it 'should add consecutive values without any problem' do
+        command.public_send limiter, :arg3
+        expect(command.limiters[limiter]).to eq %i(arg1 arg2 arg3)
+      end
+
+      it 'should not add repeated args' do
+        command.public_send limiter, :arg1, :arg4
+        expect(command.limiters[limiter]).to eq %i(arg1 arg2 arg4)
+      end
+    end
+  end
+
+  context '.validate_arguments' do
+    let(:args) { { hello: :world, how: :are, you: :! } }
+
+    it 'calls .validate_required_arguments if it has requires' do
+      expect(command).to receive(:validate_required_arguments).and_return(true)
+      command.requires :something
+      command.validate_arguments args
+    end
+
+    it 'does not call .validate_required_arguments if theres no requires' do
+      expect(command).to_not receive(:validate_required_arguments)
+      command.validate_arguments args
+    end
+
+    it 'does not call .validate_required_arguments with skip_validations: :requires option' do
+      command.requires :something
+      expect(command).to_not receive(:validate_required_arguments)
+      command.validate_arguments args, skip_validations: :requires
+    end
+
+    it 'calls .validate_received_arguments if it has receives' do
+      expect(command).to receive(:validate_received_arguments).and_return(true)
+      command.receives :something
+      command.validate_arguments args
+    end
+
+    it 'does not call .validate_received_argumnts if theres no receives' do
+      expect(command).to_not receive(:validate_received_arguments)
+      command.validate_arguments args
+    end
+
+    it 'does not call .validate_receiveed_arguments with skip_validations: :receives option' do
+      command.receives :something
+      expect(command).to_not receive(:validate_received_arguments)
+      command.validate_arguments args, skip_validations: :receives
+    end
+
+    it 'does not call either with skip_validations: true option' do
+      command.requires :something
+      command.receives :something_else
+      expect(command).to_not receive(:validate_received_arguments)
+      expect(command).to_not receive(:validate_required_arguments)
+
+      command.validate_arguments args, skip_validations: true
+    end
+  end
+
+  context '.validate_required_arguments' do
+    let(:args) { { hello: :world, how: :are, you: :! } }
+
+    it 'does nothing if the required arguments are contained in the received ones' do
+      command.requires :hello, :you
+      expect { command.validate_required_arguments args }.to_not raise_error
+    end
+
+    it 'does nothing if it receives extra arguments' do
+      command.requires :hello, :you
+      expect { command.validate_required_arguments(**args, extra: :arg) }.to_not raise_error
+    end
+
+    it 'raises an error when the required arguments are not fully contained in the received ones' do
+      command.requires :hello, :you, :doc
+      expect { command.validate_required_arguments args }.to raise_error AyeCommander::MissingRequiredArgumentError
+    end
+  end
+
+  context '.validate_received_arguments' do
+    let(:args) { { hello: :world, how: :are, you: :! } }
+
+    it 'does nothing if receives contains all the received arguments' do
+      command.receives :hello, :how, :you
+      expect { command.validate_received_arguments args }.to_not raise_error
+    end
+
+    it 'does nothing if some of the arguments are missing' do
+      command.receives :hello, :how, :you, :potato
+      expect { command.validate_received_arguments args }.to_not raise_error
+    end
+
+    it 'raises an error when it receives arguments not contained in the receives array' do
+      command.receives :hello, :how, :potato
+      expect { command.validate_received_arguments args }.to raise_error AyeCommander::UnexpectedReceivedArgumentError
+    end
+  end
+end