def test_can_generate_code_with_xsd_refs_to_simple_elements(self): xml = utils.open_document( 'tests/assets/generation/reference_simple.xsd') code = xsd2py.generate_code_from_xsd(xml) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) # somehow we need to be able to have schemas with multiple possible # root elements assert_length(3, symbols) assert_contains('Name', symbols.keys()) assert_contains('Job', symbols.keys()) assert_equals(set(['name', 'job']), list(schemas[0].elements)) Job = symbols['Job'] Name = symbols['Name'] name_ref = Job.name # not sure if these assertions are correct but they should give you # the idea assert_isinstance(name_ref, xsd.Ref) assert_equals(name_ref._type, Name) job = Job() # Should not raise job.name = u'Foo'
def test_can_generate_code_with_xsd_refs_to_elements_with_anoynmous_complex_types( self): # The final test should have an object graph representation of the # schema below. Currently I don't know how to represent multiple # xs:elements in a schema without using ComplexTypes. # Maybe we should have a special type like AnonymousComplexType and # put that directly into schema.elements? xml = utils.open_document( 'tests/assets/generation/reference_complex.xsd') schema = xsdspec.Schema.parse_xmlelement(etree.fromstring(xml)) code = xsd2py.schema_to_py(schema, ['xs']) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(3, symbols) assert_contains('Person', symbols.keys()) assert_contains('Job', symbols.keys()) assert_equals(set(['person', 'job']), list(schemas[0].elements)) Job = symbols['Job'] Person = symbols['Person'] person_ref = Job.person assert_isinstance(person_ref, xsd.Ref) assert_equals(person_ref._type, Person) job = Job() person = Person() person.name = 'Foo' job.person = person
def test_can_generate_code_with_xsd_refs_to_simple_elements(self): xml = utils.open_document('tests/assets/generation/reference_simple.xsd') code = xsd2py.generate_code_from_xsd(xml) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) # somehow we need to be able to have schemas with multiple possible # root elements assert_length(3, symbols) assert_contains('Name', symbols.keys()) assert_contains('Job', symbols.keys()) assert_equals(set(['name', 'job']), list(schemas[0].elements)) Job = symbols['Job'] Name = symbols['Name'] name_ref = Job.name # not sure if these assertions are correct but they should give you # the idea assert_isinstance(name_ref, xsd.Ref) assert_equals(name_ref._type, Name) job = Job() # Should not raise job.name = u'Foo'
def test_can_generate_code_with_xsd_refs_to_elements_with_anoynmous_complex_types(self): # The final test should have an object graph representation of the # schema below. Currently I don't know how to represent multiple # xs:elements in a schema without using ComplexTypes. # Maybe we should have a special type like AnonymousComplexType and # put that directly into schema.elements? xml = utils.open_document('tests/assets/generation/reference_complex.xsd') schema = xsdspec.Schema.parse_xmlelement(etree.fromstring(xml)) code = xsd2py.schema_to_py(schema, ['xs']) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(3, symbols) assert_contains('Person', symbols.keys()) assert_contains('Job', symbols.keys()) assert_equals(set(['person', 'job']), list(schemas[0].elements)) Job = symbols['Job'] Person = symbols['Person'] person_ref = Job.person assert_isinstance(person_ref, xsd.Ref) assert_equals(person_ref._type, Person) job = Job() person = Person() person.name = 'Foo' job.person = person
def test_can_generate_code_for_two_schemas(self): xml = utils.open_document('tests/assets/generation/multi_schema.wsdl') code = wsdl2py.generate_code_from_wsdl(xml, 'client') schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(2, [s for s in symbols if s.startswith('Schema_')]) assert_equals(['A'], list(schemas[0].elements)) assert_equals(['B'], list(schemas[1].elements))
def test_can_generate_code_for_two_schemas(self): xml = utils.open_document("tests/assets/generation/multi_schema.wsdl") code = wsdl2py.generate_code_from_wsdl(xml, "client") schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(4, symbols) assert_equals(["A"], list(schemas[0].elements)) assert_equals(["B"], list(schemas[1].elements))
def test_can_generate_code_for_looped_wsdl_import(self): path = 'tests/assets/generation/import_looped.wsdl' xml = utils.open_document(path) code = wsdl2py.generate_code_from_wsdl(xml, 'client', cwd=os.path.dirname(path)) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas)
def test_can_generate_code_for_inheritance(self): xml = utils.open_document('tests/assets/generation/inheritance.wsdl') code = wsdl2py.generate_code_from_wsdl(xml, 'client') schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(4, symbols) assert_equals(['B', 'A'], list(schemas[0].elements)) assert_isinstance(schemas[0].elements['B']._type, xsd.String) assert_isinstance(schemas[0].elements['A']._type, schemas[0].elements['B']._type.__class__)
def test_can_generate_list_enumeration(self): xml = utils.open_document('tests/assets/generation/enumeration.xsd') code = xsd2py.generate_code_from_xsd(xml) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(2, symbols) assert_true(issubclass(symbols['MyList'], xsd.List)) my_list = symbols['MyList']() assert_equals(my_list.accept(['B']), True)
def test_can_generate_code_for_simple_element(self): xml = utils.open_document('tests/assets/generation/simple_element.xsd') code = xsd2py.generate_code_from_xsd(xml) schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) assert_length(1, symbols) assert_equals(['simpleElement'], list(schemas[0].elements)) simple_element = schemas[0].elements['simpleElement'] assert_isinstance(simple_element._type, xsd.String)
def test_can_generate_extension_imported(self): xml = utils.open_document('tests/assets/generation/extension_imported.xsd') code = xsd2py.generate_code_from_xsd(xml, cwd='tests/assets/generation') schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) base = symbols['Base'] base.Field1 try: base.Field2 except AttributeError: pass else: self.fail('Unexpected base.Field2') ct = symbols['ComplexType'] ct.Field1 ct.Field2
def test_can_generate_extension_imported(self): xml = utils.open_document( 'tests/assets/generation/extension_imported.xsd') code = xsd2py.generate_code_from_xsd(xml, cwd='tests/assets/generation') schemas, symbols = generated_symbols(code) assert_is_not_empty(schemas) base = symbols['Base'] base.Field1 try: base.Field2 except AttributeError: pass else: self.fail('Unexpected base.Field2') ct = symbols['ComplexType'] ct.Field1 ct.Field2
def assert_fail(self, value, message=None): return assert_raises(AssertionError, lambda: assert_is_not_empty(value, message=message))
def test_passes_if_value_is_not_empty(self): assert_is_not_empty((1,)) assert_is_not_empty([1]) assert_is_not_empty('foo')
def test_passes_if_value_is_not_empty(self): assert_is_not_empty((1, )) assert_is_not_empty([1]) assert_is_not_empty('foo')
def assert_fail(self, value, message=None): return assert_raises( AssertionError, lambda: assert_is_not_empty(value, message=message))
def test_can_consume_generator_if_necessary(self): def generator(): for i in (1, 2, 3): yield i assert_is_not_empty(generator())