PHP Symfony\Components\Console\Input ArrayInput::getOptions Examples

Example #1

File: InputTest.php Project: jacques-sounvi/addressbook

 public function testOptions()
 {
     $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'))));
     $this->assertEquals('foo', $input->getOption('name'), '->getOption() returns the value for the given option');
     $input->setOption('name', 'bar');
     $this->assertEquals('bar', $input->getOption('name'), '->setOption() sets the value for a given option');
     $this->assertEquals(array('name' => 'bar'), $input->getOptions(), '->getOptions() returns all option values');
     $input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
     $this->assertEquals('default', $input->getOption('bar'), '->getOption() returns the default value for optional options');
     $this->assertEquals(array('name' => 'foo', 'bar' => 'default'), $input->getOptions(), '->getOptions() returns all option values, even optional ones');
     try {
         $input->setOption('foo', 'bar');
         $this->fail('->setOption() throws a \\InvalidArgumentException if the option does not exist');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->setOption() throws a \\InvalidArgumentException if the option does not exist');
         $this->assertEquals('The "foo" option does not exist.', $e->getMessage());
     }
     try {
         $input->getOption('foo');
         $this->fail('->getOption() throws a \\InvalidArgumentException if the option does not exist');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->setOption() throws a \\InvalidArgumentException if the option does not exist');
         $this->assertEquals('The "foo" option does not exist.', $e->getMessage());
     }
 }

Example #2

File: ArrayInputTest.php Project: CodingFabian/symfony

 public function testParse()
 {
     $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
     $this->assertEquals($input->getArguments(), array('name' => 'foo'), '->parse() parses required arguments');
     try {
         $input = new ArrayInput(array('foo' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid argument is passed');
     } catch (\RuntimeException $e) {
     }
     $input = new ArrayInput(array('--foo' => 'bar'), new InputDefinition(array(new InputOption('foo'))));
     $this->assertEquals($input->getOptions(), array('foo' => 'bar'), '->parse() parses long options');
     $input = new ArrayInput(array('--foo' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
     $this->assertEquals($input->getOptions(), array('foo' => 'bar'), '->parse() parses long options with a default value');
     $input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
     $this->assertEquals($input->getOptions(), array('foo' => 'default'), '->parse() parses long options with a default value');
     try {
         $input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
         $this->fail('->parse() throws an \\InvalidArgumentException exception if a required option is passed without a value');
     } catch (\RuntimeException $e) {
     }
     try {
         $input = new ArrayInput(array('--foo' => 'foo'), new InputDefinition());
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     } catch (\RuntimeException $e) {
     }
     $input = new ArrayInput(array('-f' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f'))));
     $this->assertEquals($input->getOptions(), array('foo' => 'bar'), '->parse() parses short options');
     try {
         $input = new ArrayInput(array('-o' => 'foo'), new InputDefinition());
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     } catch (\RuntimeException $e) {
     }
 }

Example #3

File: ArrayInputTest.php Project: jacques-sounvi/addressbook

 public function testParse()
 {
     $input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
     $this->assertEquals(array('name' => 'foo'), $input->getArguments(), '->parse() parses required arguments');
     try {
         $input = new ArrayInput(array('foo' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid argument is passed');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->parse() throws an \\InvalidArgumentException exception if an invalid argument is passed');
         $this->assertEquals('The "foo" argument does not exist.', $e->getMessage(), '->parse() throws an \\InvalidArgumentException exception if an invalid argument is passed');
     }
     $input = new ArrayInput(array('--foo' => 'bar'), new InputDefinition(array(new InputOption('foo'))));
     $this->assertEquals(array('foo' => 'bar'), $input->getOptions(), '->parse() parses long options');
     $input = new ArrayInput(array('--foo' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
     $this->assertEquals(array('foo' => 'bar'), $input->getOptions(), '->parse() parses long options with a default value');
     $input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
     $this->assertEquals(array('foo' => 'default'), $input->getOptions(), '->parse() parses long options with a default value');
     try {
         $input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
         $this->fail('->parse() throws an \\InvalidArgumentException exception if a required option is passed without a value');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->parse() throws an \\InvalidArgumentException exception if a required option is passed without a value');
         $this->assertEquals('The "--foo" option requires a value.', $e->getMessage(), '->parse() throws an \\InvalidArgumentException exception if a required option is passed without a value');
     }
     try {
         $input = new ArrayInput(array('--foo' => 'foo'), new InputDefinition());
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
         $this->assertEquals('The "--foo" option does not exist.', $e->getMessage(), '->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     }
     $input = new ArrayInput(array('-f' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f'))));
     $this->assertEquals(array('foo' => 'bar'), $input->getOptions(), '->parse() parses short options');
     try {
         $input = new ArrayInput(array('-o' => 'foo'), new InputDefinition());
         $this->fail('->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     } catch (\Exception $e) {
         $this->assertInstanceOf('\\InvalidArgumentException', $e, '->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
         $this->assertEquals('The "-o" option does not exist.', $e->getMessage(), '->parse() throws an \\InvalidArgumentException exception if an invalid option is passed');
     }
 }

Example #4

File: InputTest.php Project: nicolasmartin/symfony

$t->diag('__construct()');
$input = new ArrayInput(array('name' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
$t->is($input->getArgument('name'), 'foo', '->__construct() takes a InputDefinition as an argument');

// ->getOption() ->setOption() ->getOptions()
$t->diag('->getOption() ->setOption() ->getOptions()');
$input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'))));
$t->is($input->getOption('name'), 'foo', '->getOption() returns the value for the given option');

$input->setOption('name', 'bar');
$t->is($input->getOption('name'), 'bar', '->setOption() sets the value for a given option');
$t->is($input->getOptions(), array('name' => 'bar'), '->getOptions() returns all option values');

$input = new ArrayInput(array('--name' => 'foo'), new InputDefinition(array(new InputOption('name'), new InputOption('bar', '', InputOption::PARAMETER_OPTIONAL, '', 'default'))));
$t->is($input->getOption('bar'), 'default', '->getOption() returns the default value for optional options');
$t->is($input->getOptions(), array('name' => 'foo', 'bar' => 'default'), '->getOptions() returns all option values, even optional ones');

try
{
  $input->setOption('foo', 'bar');
  $t->fail('->setOption() throws a \InvalidArgumentException if the option does not exist');
}
catch (\InvalidArgumentException $e)
{
  $t->pass('->setOption() throws a \InvalidArgumentException if the option does not exist');
}

try
{
  $input->getOption('foo');
  $t->fail('->getOption() throws a \InvalidArgumentException if the option does not exist');

Example #5

File: ArrayInputTest.php Project: nicolasmartin/symfony

  $input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
  $t->fail('->parse() throws an \InvalidArgumentException exception if a required option is passed without a value');
}
catch (\RuntimeException $e)
{
  $t->pass('->parse() throws an \InvalidArgumentException exception if a required option is passed without a value');
}

try
{
  $input = new ArrayInput(array('--foo' => 'foo'), new InputDefinition());
  $t->fail('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
catch (\RuntimeException $e)
{
  $t->pass('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}

$input = new ArrayInput(array('-f' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f'))));
$t->is($input->getOptions(), array('foo' => 'bar'), '->parse() parses short options');

try
{
  $input = new ArrayInput(array('-o' => 'foo'), new InputDefinition());
  $t->fail('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
catch (\RuntimeException $e)
{
  $t->pass('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}