view release on metacpan or  search on metacpan

t/unit/config_engine_new.t  view on Meta::CPAN

				ok !defined Context->{errors};;
				ok !defined Context->{warnings};
				ok Context->{options}->{myoption}->{seen};
				ok ! defined Context->{options}->{myoption}->{value};
			}
		};
	};
	describe "many arguments" => sub {
		it "should check options" => sub {
			localize sub {
				my @options = ('myoption', 'myoption2');
				options @options;
				App::MtAws::ConfigEngine->expects("seen")->exactly(2)->returns(1);
				deprecated @options;
			}
		};
		it "should work when 2 of 2 optional option presents" => sub {
			localize sub {
				local $_ = 'abc';
				message 'option_deprecated_for_command';
				my @options = ('myoption', 'myoption2');
				options @options;
				@{Context->{options}->{myoption}}{qw/value source/} = (123, 'option');
				@{Context->{options}->{myoption2}}{qw/value source/} = (123, 'option');
				my @res = deprecated @options;
				cmp_deeply [@res], [@options];
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen};
				ok Context->{options}->{myoption2}->{seen};
				cmp_deeply Context->{warnings}, [{format => 'option_deprecated_for_command', a => 'myoption'}, {format => 'option_deprecated_for_command', a => 'myoption2'}];
				ok $_ eq 'abc';
			}
		};
		it "should work when 1 of 2 optional option presents" => sub {
			localize sub {
				message 'option_deprecated_for_command';
				options my @options = ('myoption', 'myoption2');
				@{Context->{options}->{myoption}}{qw/value source/} = (123, 'option');
				my @res = deprecated @options;
				cmp_deeply [@res], [@options];
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen};
				ok Context->{options}->{myoption2}->{seen};
				cmp_deeply Context->{warnings}, [{format => 'option_deprecated_for_command', a => 'myoption'}];
			}
		};
		it "should work when 0 of 2 optional option presents" => sub {
			localize sub {
				message 'option_deprecated_for_command';
				options my @options = ('myoption', 'myoption2');
				my @res = deprecated @options;
				cmp_deeply [@res], [@options];
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen};
				ok Context->{options}->{myoption2}->{seen};
			}
		};
	};
};

describe "validate" => sub {
	it "should check option" => sub {
		localize sub {
			option 'myoption';
			App::MtAws::ConfigEngine->expects("seen")->once()->returns(1);
			validate('myoption2');
		}
	};
	describe "validation is defined" => sub {
		it "should work when validation passed" => sub {
			localize sub {
				local $_ = 'abc';
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				Context->{options}->{myoption}->{value} = '123';
				my ($res) = validate 'myoption';
				ok $res eq 'myoption';
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated} && Context->{options}->{myoption}->{valid};
				ok $_ eq 'abc';
			}
		};
		it "should work when validation failed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				Context->{options}->{myoption}->{value} = '7';
				my ($res) = validate 'myoption';
				ok $res eq 'myoption';
				cmp_deeply Context->{errors}, [ { format => 'myerror', a => 'myoption', value => 7 }];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
			}
		};
		it "should work when validation failed with alias" => sub {
			localize sub {
				validation option('myoption', alias => 'old'), 'myerror', sub { $_ > 10 };
				Context->{options}->{myoption}->{value} = '7';
				Context->{options}->{myoption}->{original_option} = 'old';
				my ($res) = validate 'myoption';
				ok $res eq 'myoption';
				cmp_deeply Context->{errors}, [ { format => 'myerror', a => 'old', value => 7 }];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
			}
		};
	};
	describe "validation is not defined" => sub {
		it "should work" => sub {
			localize sub {
				option 'myoption';
				Context->{options}->{myoption}->{value} = '123';
				my ($res) = validate 'myoption';
				ok $res eq 'myoption';
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated} && Context->{options}->{myoption}->{valid};
			}
		};
	};
	describe "option is not present" => sub {
		it "should work" => sub {
			localize sub {
				option 'myoption';
				my ($res) = validate 'myoption';
				ok $res eq 'myoption';
				ok !defined Context->{errors};
				ok Context->{options}->{myoption}->{seen};
				ok ! (Context->{options}->{myoption}->{validated} || Context->{options}->{myoption}->{valid});
			}
		};
	};
	describe "several validations for one option" => sub {
		it "should not perform second validation if stop is true and first failed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', stop => 1, sub { $_ > 10 };
				validation 'myoption', 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '1';
				my (@res) = validate qw/myoption/;
				cmp_deeply [@res], [qw/myoption/];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
				cmp_deeply Context->{errors}, [ { format => 'myerror', a => 'myoption', value =>1 }];
			}
		};
		it "should perform second validation if stop is false and first failed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				validation 'myoption', 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '1';
				my (@res) = validate qw/myoption/;
				cmp_deeply [@res], [qw/myoption/];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
				cmp_deeply Context->{errors}, [ { format => 'myerror', a => 'myoption', value => 1 }, { format => 'myerror2', a => 'myoption', value => 1 }];
			}
		};
		it "should perform second validation if first passed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ % 2 == 0 };
				validation 'myoption', 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = 6;
				my (@res) = validate qw/myoption/;
				cmp_deeply [@res], [qw/myoption/];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
				cmp_deeply Context->{errors}, [ { format => 'myerror2', a => 'myoption', value => 6 }];
			}
		};
	};
	describe "several validations, max. one per option" => sub {
		it "should check option" => sub {
			localize sub {
				options qw/myoption myoption2/;
				App::MtAws::ConfigEngine->expects("seen")->exactly(2)->returns(1);
				validate(qw/myoption2 myoption/);
			}
		};
		it "should work when both failed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				validation option('myoption2'), 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '1';
				Context->{options}->{myoption2}->{value} = '2';
				my (@res) = validate qw/myoption myoption2/;
				cmp_deeply [@res], [qw/myoption myoption2/];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated};
				ok !Context->{options}->{myoption}->{valid};
				ok Context->{options}->{myoption2}->{seen} && Context->{options}->{myoption2}->{validated};
				ok !Context->{options}->{myoption2}->{valid};
				cmp_deeply Context->{errors}, [ { format => 'myerror', a => 'myoption', value => 1 },
					{ format => 'myerror2', a => 'myoption2', value => 2 }];
			}
		};
		it "error order should match validation order" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				validation option('myoption2'), 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '1';
				Context->{options}->{myoption2}->{value} = '2';
				my (@res) = validate qw/myoption2 myoption/;
				cmp_deeply Context->{errors}, [ { format => 'myerror2', a => 'myoption2', value => 2 },
					{ format => 'myerror', a => 'myoption', value => 1 }];
			}
		};
		it "should work when one failed" => sub {
			localize sub {
				validation option('myoption'), 'myerror', sub { $_ > 10 };
				validation option('myoption2'), 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '11';
				Context->{options}->{myoption2}->{value} = '2';
				my (@res) = validate qw/myoption myoption2/;
				cmp_deeply [@res], [qw/myoption myoption2/];
				ok Context->{options}->{myoption}->{seen} && Context->{options}->{myoption}->{validated} && Context->{options}->{myoption}->{valid};
				ok Context->{options}->{myoption2}->{seen} && Context->{options}->{myoption2}->{validated};
				ok !Context->{options}->{myoption2}->{valid};
				cmp_deeply Context->{errors}, [ { format => 'myerror2', a => 'myoption2', value => 2 }];
			}
		};
		it "should work when one failed" => sub {
			localize sub {
				options qw/myoption/;
				validation option('myoption2'), 'myerror2', sub { $_ > 9 };
				Context->{options}->{myoption}->{value} = '2';
				Context->{options}->{myoption2}->{value} = '2';
				my (@res) = validate qw/myoption myoption2/;
				cmp_deeply [@res], [qw/myoption myoption2/];
				ok Context->{options}->{myoption}->{seen};
				ok Context->{options}->{myoption2}->{seen};
				cmp_deeply Context->{errors}, [ { format => 'myerror2', a => 'myoption2', value => 2 }];
			}
		};
	};
};

describe "scope" => sub {
	describe "with one argument" => sub {
		it "should work with one scope" => sub {
			localize sub {
				option 'myoption';
				my @res = scope 'myscope', 'myoption';
				cmp_deeply [@res], ['myoption'];
				cmp_deeply Context->{options}->{myoption}->{scope}, ['myscope'];
			}
		};
		it "should work with one two scopes" => sub {
			localize sub {
				option 'myoption';
				my @res = scope 'outer', scope 'inner', 'myoption';
				cmp_deeply [@res], ['myoption'];
				cmp_deeply Context->{options}->{myoption}->{scope}, ['outer', 'inner'];
			}
		};
	};
	describe "with several arguments" => sub {
		it "should check option" => sub {
			localize sub {
				App::MtAws::ConfigEngine->expects("assert_option")->exactly(2);
				scope 'myscope', qw/myoption myoption2/;
			}
		};
		it "should work with one scope" => sub {
			localize sub {
				local $_ = 'abc';
				options qw/o1 o2/;
				my @res = scope 'sc', qw/o1 o2/;
				cmp_deeply [@res], [qw/o1 o2/];
				cmp_deeply Context->{options}->{$_}->{scope}, ['sc'] for qw/o1 o2/;
				ok $_ eq 'abc';
			}
		};
		it "should work with two scopes" => sub {
			localize sub {
				options qw/o1 o2/;
				my @res = scope 'outer', scope 'inner', qw/o1 o2/;
				cmp_deeply [@res], [qw/o1 o2/];
				cmp_deeply Context->{options}->{$_}->{scope}, ['outer', 'inner'] for qw/o1 o2/;
			}
		};
	};
};

describe "present" => sub {
	it "should check option " => sub {
		localize sub {
			local $_ = 'abc';

t/unit/config_engine_new.t  view on Meta::CPAN

			option 'myoption';
			option 'myoption2';
			Context->{options}->{myoption}->{value} = 1;
			App::MtAws::ConfigEngine->expects("assert_option")->exactly(2);
			ok present for 'myoption';
			ok !present for 'myoption2';
			ok $_ eq 'abc';
		}
	};
	it "should work when option exists " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 1;
			ok present('myoption');
		}
	};
	it "should work when option not exists " => sub {
		localize sub {
			option 'myoption';
			ok ! present 'myoption'
		}
	};
};

describe "value" => sub {
	it "should check option " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			App::MtAws::ConfigEngine->expects("assert_option")->once();
			is 42, value('myoption');
		}
	};
	it "should work when option exists " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			is 42, value('myoption');
		}
	};
	it "should work when option exists and empty string" => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = '';
			is '', value('myoption');
		}
	};
	it "should die when option not exists " => sub {
		localize sub {
			option 'myoption';
			ok ! defined eval { value 'myoption'; 1 };
		}
	};
};

describe "valid" => sub {
	it "should check option " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			Context->{options}->{myoption}->{validated} = 1;
			Context->{options}->{myoption}->{valid} = 1;
			App::MtAws::ConfigEngine->expects("assert_option")->once();
			ok valid('myoption');
		}
	};
	it "should work when option valid " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			Context->{options}->{myoption}->{validated} = 1;
			Context->{options}->{myoption}->{valid} = 1;
			ok valid('myoption');
		}
	};
	it "should work when option not valid " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			Context->{options}->{myoption}->{validated} = 1;
			Context->{options}->{myoption}->{valid} = 0;
			ok !valid('myoption');
		}
	};
	it "should die when option not validated " => sub {
		localize sub {
			option 'myoption';
			Context->{options}->{myoption}->{value} = 42;
			ok ! defined eval { ok valid('myoption'); 1 };
		}
	};
};

describe "custom" => sub {
	it "should not redefine option" => sub {
		localize sub {
			option 'myoption';
			ok ! defined eval { custom 'myoption', 42; 1; };
		}
	};
	it "should work " => sub {
		localize sub {
			my $res = custom 'myoption', 42; 1;
			ok $res eq 'myoption';
			cmp_deeply Context->{options}->{myoption}, { name => 'myoption', value => 42, source => 'set', seen => 1 };
		}
	};
};

describe "error" => sub {
	it "should work" => sub {
		localize sub {
			error 'myerror';
			cmp_deeply Context->{errors}, ['myerror'];
		}
	};
	it "should push errors to stack" => sub {
		localize sub {
			error 'myerror';
			error 'myerror2';
			cmp_deeply Context->{errors}, ['myerror', 'myerror2'];
		}
	};
};

describe "warning" => sub {
	it "should work" => sub {
		localize sub {
			warning 'myerror';
			cmp_deeply Context->{warnings}, ['myerror'];
		}
	};
	it "should push warnings to stack" => sub {
		localize sub {
			warning 'mywarning';
			warning 'mywarning2';
			cmp_deeply Context->{warnings}, ['mywarning', 'mywarning2'];
		}
	};
};

describe "error to message" => sub {
	sub error_to_message { &App::MtAws::ConfigEngine::error_to_message };
	
	it "should work without format" => sub {