require File.expand_path(File.dirname(__FILE__) + '/spec_helper') class Tester include ::Trigga::ParamFu end describe ::Trigga::ParamFu do before(:each) do @t = Tester.new end describe "class methods" do describe "key_with_id" do it "should add '_id' onto the given symbol" do Tester.key_with_id(:blart).should == :blart_id end end describe "obj_or_id" do describe "when the given hash already contains :(given_key)_id" do it "should not change the value of that _id key" do @my_obj = mock("object") @my_obj.stub!(:id).and_return(456) @my_hash = {:my_key_id=>123, :my_obj=>@my_obj} Tester.obj_or_id( @my_hash, :my_key ) @my_hash[:my_key_id].should == 123 end end describe "when the given hash does not already contain :(given_key)_id" do describe "and the given hash contains the given key without an added _id" do it "should set the :(given_key)_id to the id of the object" do @mock_obj = mock("obj") @mock_obj.stub!(:id).and_return(123) Tester.obj_or_id( {:my_obj=>@mock_obj}, :my_obj ).should == 123 end end end end describe "require_param" do context "when given a single key" do context "when key is not present in opts" do it "should raise an ArgumentError" do lambda{ Tester.require_param( {:key1=>'value1'}, :key2 ) }.should raise_error(ArgumentError) end end context "when key is present in opts" do it "should not raise an error" do lambda{ Tester.require_param( {:key1=>'value1'}, :key1 ) }.should_not raise_error(ArgumentError) end end end context "when given multiple keys" do context "when all keys are present" do it "should not raise an error" do lambda{ Tester.require_param( {:key1=>'value1', :key2=>'value2'}, :key2, :key1 ) }.should_not raise_error(ArgumentError) end end context "when at least one key is not present" do it "should raise an ArgumentError " do lambda{ Tester.require_param( {:key1=>'value1', :key2=>'value2'}, :key2, :key1, :key3 ) }.should raise_error(ArgumentError) end end end end describe "require_obj_or_id" do context "when the key is present" do it "should not raise an error" do lambda{ Tester.require_obj_or_id( {:obj_name=>'value1'}, :obj_name ) }.should_not raise_error(ArgumentError) end end context "when the key is not present" do context "when the key suffixed with _id is present" do it "should not raise an error" do lambda{ Tester.require_obj_or_id( {:obj_id=>'value1'}, :obj ) }.should_not raise_error(ArgumentError) end end context "when the key is not present even suffixed with _id" do it "should raise an error" do lambda{ Tester.require_obj_or_id( {:key1=>'value1', :key2_id=>123}, :key3 ) }.should raise_error(ArgumentError) end end end end describe "require_one_of" do context "when at least one of the given keys is contained in opts" do it "should not raise an error" do lambda{ Tester.require_one_of( {:obj=>'value1'}, :foo, :bar, :obj ) }.should_not raise_error(ArgumentError) end end context "when none of the given keys are contained in opts" do it "should raise an error" do lambda{ Tester.require_one_of( {:obj=>'value1'}, :foo, :bar ) }.should raise_error(ArgumentError) end end end describe "id_or_name_condition" do it "should return a hash" do Tester.id_or_name_condition('mymodel', 'string_value').should be_a Hash end it "should have a key for :where" do Tester.id_or_name_condition('mymodel', 'string_value').keys.should include(:where) end it "should have a key for :values" do Tester.id_or_name_condition('mymodel', 'string_value').keys.should include(:values) end context "when given a string value" do it "should include '(table).name like ?' in the where clause" do Tester.id_or_name_condition('mymodel', 'string_value')[:where].should =~ /mymodel\.name\s*like\s*\?/i end it "should include the given value in values, wrapped in wildcard markers" do Tester.id_or_name_condition('mymodel', 'string_value')[:values].should == '%string_value%' end context "and the value has an id in brackets on the end" do it "should strip the brackets and value" do Tester.id_or_name_condition('mymodel', 'string_value (1234)')[:values].should_not =~ /\([0-9]*\)/ end it "should strip any space before the brackets" do Tester.id_or_name_condition('mymodel', 'string_value (1234)')[:values].should == "%string_value%" end end end context "when given an integer value" do it "should include '(table).id == ?' in the where clause" do Tester.id_or_name_condition('mymodel', '2')[:where].should =~ /mymodel\.id\s*=\s*\?/i end it "should include the given value in values, as an integer" do Tester.id_or_name_condition('mymodel', '2')[:values].should == 2 end end end describe "parse_field_definition" do before(:each) do @params = { :param_1 => 'param_1 value' } @model_class = mock("model class") @model_class.stub!(:table_name).and_return( 'model_class_table_name' ) @param_name = :param_name @definition = { :operator=>'=', :field_name=>'field_name'} end it "should return a Hash" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition ).should be_a(Hash) end describe "returned Hash" do it "should have a key for :where" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].should_not be_nil end it "should have a key for :values" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should_not be_nil end context "when the given opts has a key matching the given param_name" do before(:each) do @param_name = :param_1 end context "and the param value is not empty" do it "should add an element to the :where key" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].size.should == 1 end describe "where clause" do it "should be wrapped in brackets" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].should =~ /^\s*\(.*\)\s*$/ end describe "inside the brackets" do before(:each) do @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1') end it "should start with the model_class's table name as a scope" do @inside_the_brackets.should =~ /\s*model_class_table_name\..*/ end context "When the definition has a :fieldname" do before(:each) do @definition[:field_name] = 'field_name' @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1') end it "should use the :fieldname" do @inside_the_brackets.should =~ /\s*[^\.]+\.field_name.*/ end end context "When the definition has no :fieldname" do before(:each) do @definition[:field_name] = nil @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1') end it "should use the given param_name converted to a string as the field name" do @inside_the_brackets.should =~ /\s*[^\.]+\.param_1.*/ end end context "When the definition has a :operator" do before(:each) do @definition[:operator] = 'my_operator' @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1') end it "should use the :operator" do @inside_the_brackets.should =~ /.*\bmy_operator\b.*/ end end context "When the definition has no :operator" do before(:each) do @definition[:operator] = nil @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1') end it "should use = as the :operator" do @inside_the_brackets.should =~ /[^=]+\s*=\s*[^=]+/ end end it "should end with (?)" do @inside_the_brackets.should =~ /\(\?\)\s*$/ end end end context "when the given :operator matches 'like'" do before(:each) do @definition[:operator] = " LIKE " end it "should add the corresponding value, converted to a like condition, to the :values key" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should == ['%param_1%value%'] end end it "should add the corresponding value to the :values key" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should == ['param_1 value'] end end context "when the given value is empty" do before(:each) do @params = {:param_1=>'', :param_2=>'dave'} @param_name = :param_1 end it "should not add the key to the where clause" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].should be_empty end it "should not add the value to the :values key" do Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should_not include('') end end end end end describe "model_conditions" do before(:each) do @params = { :param_1 => 'param_1 value' } @model_class = mock("model class") @mock_parsed_field_def_1 = {:where=>['where 1'], :values=>['values 1']} @mock_parsed_field_def_2 = {:where=>['where 2'], :values=>['values 2']} Tester.stub!(:parse_field_definition).and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 ) @definitions = { :key=>'=', :field_name=>'field_name'} end it "should return a Hash" do Tester.model_conditions( @params, @model_class, @definitions ).should be_a(Hash) end describe "returned Hash" do it "should have a key for :where" do Tester.model_conditions( @params, @model_class, @definitions )[:where].should_not be_nil end it "should have a key for :values" do Tester.model_conditions( @params, @model_class, @definitions )[:values].should_not be_nil end end context "for each given field_def" do before(:each) do @definitions = { :field_name_1 => (@mock_definition_1={}), :field_name_2 => (@mock_definition_2={}) } end it "should call parse_field_definition" do Tester.should_receive(:parse_field_definition).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 ) Tester.model_conditions( @params, @model_class, @definitions ) end describe "parse_field_definition call params" do it "should pass the given opts" do Tester.should_receive(:parse_field_definition).with( @params, anything, anything, anything ).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 ) Tester.model_conditions( @params, @model_class, @definitions ) end it "should pass the given model class" do Tester.should_receive(:parse_field_definition).with( anything, @model_class, anything, anything ).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 ) Tester.model_conditions( @params, @model_class, @definitions ) end it "should pass each field_name" do Tester.should_receive(:parse_field_definition) do |args| args[2].should == :field_name_1 @mock_parsed_field_def_1 end Tester.should_receive(:parse_field_definition) do |args| args[2].should == :field_name_2 @mock_parsed_field_def_2 end Tester.model_conditions( @params, @model_class, @definitions ) end it "should pass the field_name's definition" do Tester.should_receive(:parse_field_definition) do |args| args[3].should == @mock_definition_1 @mock_parsed_field_def_1 end Tester.should_receive(:parse_field_definition) do |args| args[3].should == @mock_definition_2 @mock_parsed_field_def_2 end Tester.model_conditions( @params, @model_class, @definitions ) end end it "should add the :where key from the parsed field definition to the :where key of the return hash " do Tester.model_conditions( @params, @model_class, @definitions )[:where].should == ['where 1', 'where 2'] end it "should add the :values key from the parsed field definition to the :values key of the return hash " do Tester.model_conditions( @params, @model_class, @definitions )[:values].should == ['values 1', 'values 2'] end end end describe "params_to_conditions" do before(:each) do @mock_params = mock('params') @model_class_1 = "model class 1" @model_class_2 = "model class 2" @models = { @model_class_1 => 'model class def 1', @model_class_2 => 'model class def 2' } @mock_parsed_model_def_1 = {:where=>['where 1'], :values=>['values 1']} @mock_parsed_model_def_2 = {:where=>['where 2'], :values=>['values 2']} Tester.stub!(:model_conditions).and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 ) end context "when not given a :params key" do it "should raise an ArgumentError" do lambda{ Tester.params_to_conditions(:blart=>'flange', :models=>'models') }.should raise_error(ArgumentError) end end context "when not given a :models key" do it "should raise an ArgumentError" do lambda{ Tester.params_to_conditions(:blart=>'flange', :params=>'params') }.should raise_error(ArgumentError) end end context "for each given model" do before(:each) do end it "should call model_conditions" do Tester.should_receive(:model_conditions).twice.and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 ) Tester.params_to_conditions( :params=>@mock_params, :models=>@models ) end describe "model_conditions_call_params" do it "should pass on the given :params" do Tester.should_receive(:model_conditions).with(@mock_params, anything, anything).twice.and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 ) Tester.params_to_conditions( :params=>@mock_params, :models=>@models ) end it "should pass each model class" do Tester.should_receive(:model_conditions) do |args| args[1].should == 'model class 1' @mock_parsed_model_def_1 end Tester.should_receive(:model_conditions) do |args| args[1].should == 'model class 2' @mock_parsed_model_def_2 end Tester.params_to_conditions( :params=>@mock_params, :models=>@models ) end it "should pass the models field definitions" do Tester.should_receive(:model_conditions) do |args| args[2].should == 'model class def 1' @mock_parsed_model_def_1 end Tester.should_receive(:model_conditions) do |args| args[2].should == 'model class def 2' @mock_parsed_model_def_2 end Tester.params_to_conditions( :params=>@mock_params, :models=>@models ) end end end describe "returned value" do it "should be an array" do Tester.params_to_conditions( :params=>@mock_params, :models=>@models ).should be_a(Array) end describe "first element" do it "should be a string" do Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[0].should be_a(String) end it "should have the :where keys from the parsed model definitions joined with AND " do Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[0].should == "where 1 AND where 2" end end describe "subsequent elements" do it "should be the values from the parsed model definitions" do Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[1].should == 'values 1' Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[2].should == 'values 2' end end end end end describe "instance_methods" do it "should not raise an error" do lambda { @t.require_obj_or_id( {:key=>'val'}, :key ) }.should_not raise_error end end end