Ejemplo n.º 1
0
def modify_revision_arguments(argument_table, session, **kwargs):
    s3_model = create_argument_model_from_schema(S3_LOCATION_SCHEMA)
    argument_table[S3_LOCATION_ARG_DESCRIPTION['name']] = (S3LocationArgument(
        argument_model=s3_model,
        session=session,
        **S3_LOCATION_ARG_DESCRIPTION))
    github_model = create_argument_model_from_schema(GITHUB_LOCATION_SCHEMA)
    argument_table[GITHUB_LOCATION_ARG_DESCRIPTION['name']] = (
        GitHubLocationArgument(argument_model=github_model,
                               session=session,
                               **GITHUB_LOCATION_ARG_DESCRIPTION))
    argument_table['revision'].required = False
Ejemplo n.º 2
0
 def test_gen_structure_list_scalar_docs(self):
     schema = {
         "type": "object",
         "properties": {
             "Consistent": {
                 "type": "boolean",
             },
             "Args": {
                 "type": "array",
                 "items": {
                     "type": "string"
                 }
             }
         }
     }
     argument_model = create_argument_model_from_schema(schema)
     m = model.DenormalizedStructureBuilder().with_members(
         OrderedDict([
             ('Consistent', {
                 'type': 'boolean'
             }),
             ('Args', {
                 'type': 'list',
                 'member': {
                     'type': 'string',
                 }
             }),
         ])).build_model()
     generated_example = self.shorthand_documenter.generate_shorthand_example(
         '--foo', m)
     self.assertIn('Consistent=boolean,Args=string,string',
                   generated_example)
Ejemplo n.º 3
0
    def test_struct_list_scalars(self):
        schema = {
            "type": "object",
            "properties": {
                "Consistent": {
                    "type": "boolean",
                },
                "Args": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('test', argument_model=argument_model)

        returned = self.shorthand(cli_argument,
                                  'Consistent=true,Args=foo1,foo2',
                                  'process-cli-arg.foo.bar')
        self.assertEqual(returned, {
            'Consistent': True,
            'Args': ['foo1', 'foo2']
        })
Ejemplo n.º 4
0
def modify_revision_arguments(argument_table, operation, **kwargs):
    session = operation.session
    s3_model = create_argument_model_from_schema(S3_LOCATION_SCHEMA)
    argument_table[S3_LOCATION_ARG_DESCRIPTION['name']] = (
        S3LocationArgument(
            argument_model=s3_model,
            session=session,
            **S3_LOCATION_ARG_DESCRIPTION)
    )
    github_model = create_argument_model_from_schema(GITHUB_LOCATION_SCHEMA)
    argument_table[GITHUB_LOCATION_ARG_DESCRIPTION['name']] = (
        GitHubLocationArgument(
            argument_model=github_model,
            session=session,
            **GITHUB_LOCATION_ARG_DESCRIPTION)
    )
    argument_table['revision'].required = False
Ejemplo n.º 5
0
    def _build_arg_table(self):
        arg_table = OrderedDict()
        self._session.emit('building-arg-table.%s' % self.NAME,
                           arg_table=self.ARG_TABLE)
        for arg_data in self.ARG_TABLE:

            # If a custom schema was passed in, create the argument_model
            # so that it can be validated and docs can be generated.
            if 'schema' in arg_data:
                argument_model = create_argument_model_from_schema(
                    arg_data.pop('schema'))
                arg_data['argument_model'] = argument_model
            custom_argument = CustomArgument(**arg_data)

            arg_table[arg_data['name']] = custom_argument
        return arg_table
Ejemplo n.º 6
0
    def _build_arg_table(self):
        arg_table = OrderedDict()
        self._session.emit('building-arg-table.%s' % self.NAME,
                           arg_table=self.ARG_TABLE)
        for arg_data in self.ARG_TABLE:

            # If a custom schema was passed in, create the argument_model
            # so that it can be validated and docs can be generated.
            if 'schema' in arg_data:
                argument_model = create_argument_model_from_schema(
                    arg_data.pop('schema'))
                arg_data['argument_model'] = argument_model
            custom_argument = CustomArgument(**arg_data)

            arg_table[arg_data['name']] = custom_argument
        return arg_table
Ejemplo n.º 7
0
    def test_list_structure_list_scalar_custom_arg(self):
        schema = {
            'type': 'array',
            'items': {
                'type': 'object',
                'properties': {
                    'Name': {
                        'type': 'string'
                    },
                    'Args': {
                        'type': 'array',
                        'items': {
                            'type': 'string'
                        }
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('foo', argument_model=argument_model)

        expected = [{
            "Name": "foo",
            "Args": ["a", "k1=v1", "b"]
        }, {
            "Name": "bar",
            "Args": ["baz"]
        }, {
            "Name": "single_kv",
            "Args": ["key=value"]
        }, {
            "Name": "single_v",
            "Args": ["value"]
        }]

        simplified = self.simplify(cli_argument, [
            "Name=foo,Args=[a,k1=v1,b]", "Name=bar,Args=baz",
            "Name=single_kv,Args=[key=value]", "Name=single_v,Args=[value]"
        ])

        self.assertEqual(simplified, expected)
Ejemplo n.º 8
0
    def test_struct_list_scalars(self):
        schema = {
            "type": "object",
            "properties": {
                "Consistent": {
                    "type": "boolean",
                },
                "Args": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('test', argument_model=argument_model)

        returned = self.simplify(cli_argument, 'Consistent=true,Args=foo1,foo2')
        self.assertEqual(returned, {'Consistent': True,
                                    'Args': ['foo1', 'foo2']})
Ejemplo n.º 9
0
    def test_list_structure_list_scalar_custom_arg(self):
        schema = {
            'type': 'array',
            'items': {
                'type': 'object',
                'properties': {
                    'Name': {
                        'type': 'string'
                    },
                    'Args': {
                        'type': 'array',
                        'items': {
                            'type': 'string'
                        }
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('foo', argument_model=argument_model)

        expected = [
            {"Name": "foo",
             "Args": ["a", "k1=v1", "b"]},
            {"Name": "bar",
             "Args": ["baz"]},
            {"Name": "single_kv",
             "Args": ["key=value"]},
            {"Name": "single_v",
             "Args": ["value"]}
        ]

        simplified = self.simplify(cli_argument, [
            "Name=foo,Args=[a,k1=v1,b]",
            "Name=bar,Args=baz",
            "Name=single_kv,Args=[key=value]",
            "Name=single_v,Args=[value]"
        ])

        self.assertEqual(simplified, expected)
Ejemplo n.º 10
0
    def test_gen_structure_list_scalar_docs(self):
        schema = {
            "type": "object",
            "properties": {
                "Consistent": {
                    "type": "boolean",
                },
                "Args": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('test', argument_model=argument_model)

        generated_example = self.get_generated_example_for(cli_argument)
        self.assertIn('Key value pairs', generated_example)
        self.assertIn('Consistent=boolean1,Args=string1,string2',
                      generated_example)
Ejemplo n.º 11
0
    def test_gen_structure_list_scalar_docs(self):
        schema = {
            "type": "object",
            "properties": {
                "Consistent": {
                    "type": "boolean",
                },
                "Args": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            }
        }
        argument_model = create_argument_model_from_schema(schema)
        cli_argument = CustomArgument('test', argument_model=argument_model)

        generated_example = self.get_generated_example_for(cli_argument)
        self.assertIn('Key value pairs', generated_example)
        self.assertIn('Consistent=boolean1,Args=string1,string2',
                      generated_example)
Ejemplo n.º 12
0
 def test_gen_structure_list_scalar_docs(self):
     schema = {
         "type": "object",
         "properties": {
             "Consistent": {
                 "type": "boolean",
             },
             "Args": {
                 "type": "array",
                 "items": {
                     "type": "string"
                 }
             }
         }
     }
     argument_model = create_argument_model_from_schema(schema)
     m = model.DenormalizedStructureBuilder().with_members(OrderedDict([
         ('Consistent', {'type': 'boolean'}),
         ('Args', { 'type': 'list', 'member': { 'type': 'string', }}),
     ])).build_model()
     generated_example = self.shorthand_documenter.generate_shorthand_example(
         '--foo', m)
     self.assertIn('Consistent=boolean,Args=string,string',
                   generated_example)
Ejemplo n.º 13
0
 def assert_custom_shape_type(self, schema, expected_type):
     argument_model = create_argument_model_from_schema(schema)
     argument = CustomArgument('test', argument_model=argument_model)
     actual_structure = detect_shape_structure(argument.argument_model)
     self.assertEqual(actual_structure, expected_type)
Ejemplo n.º 14
0
 def assert_custom_shape_type(self, schema, expected_type):
     argument_model = create_argument_model_from_schema(schema)
     argument = CustomArgument('test', argument_model=argument_model)
     actual_structure = detect_shape_structure(argument.argument_model)
     self.assertEqual(actual_structure, expected_type)