helpers = require('../helpers')
AWS = helpers.AWS
matchXML = helpers.matchXML

describe 'AWS.XML.Builder', ->

  xmlns = 'http://mockservice.com/xmlns'
  api = null

  beforeEach ->
    api = new AWS.Model.Api metadata: xmlNamespace: xmlns

  toXML = (rules, params) ->
    rules.type = 'structure'
    shape = AWS.Model.Shape.create(rules, api: api)

    builder = new AWS.XML.Builder()
    builder.toXML(params, shape, 'Data')

  describe 'toXML', ->
    it 'wraps simple structures with location of body', ->
      rules = members: { Name:{}, State:{} }
      params = { Name:'abc', State: 'Enabled' }
      xml = """
      <Data xmlns="#{xmlns}">
        <Name>abc</Name>
        <State>Enabled</State>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'ignores null input', ->
      rules = members: { Name:{}, State:{} }
      params = { Name:null, State:undefined }
      xml = ''
      matchXML(toXML(rules, params), xml)

    it 'ignores nested null input', ->
      rules = members: {Struct:{type: 'structure', members: {State:{}}}}
      params = { Struct: { State: null } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Struct/>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'orders xml members by the order they appear in the rules', ->
      rules = xmlOrder: ['Count', 'State'], members: {Count:{type:'integer'},State:{}}
      params = { State: 'Disabled', Count: 123 }
      xml = """
      <Data xmlns="#{xmlns}">
        <Count>123</Count>
        <State>Disabled</State>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'can serializes structures into XML', ->
      rules = members:
        Name: {}
        Details:
          type: 'structure'
          members:
            Abc: {}
            Xyz: {}
      params =
        Details:
          Xyz: 'xyz'
          Abc: 'abc'
        Name: 'john'
      xml = """
      <Data xmlns="#{xmlns}">
        <Name>john</Name>
        <Details>
          <Abc>abc</Abc>
          <Xyz>xyz</Xyz>
        </Details>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'serializes empty structures as empty element', ->
      rules = {members:{Config:{type:'structure',members:{Foo:{},Bar:{}}}}}
      params = { Config: {} }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config/>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'does not serialize missing members', ->
      rules = {members:{Config:{type:'structure',members:{Foo:{},Bar:{}}}}}
      params = { Config: { Foo: 'abc' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config>
          <Foo>abc</Foo>
        </Config>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'lists', ->

    it 'serializes lists (default member names)', ->
      rules = {members:{Aliases:{type:'list',member:{}}}}
      params = {Aliases:['abc','mno','xyz']}
      xml = """
      <Data xmlns="#{xmlns}">
        <Aliases>
          <member>abc</member>
          <member>mno</member>
          <member>xyz</member>
        </Aliases>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'serializes lists (custom member names)', ->
      rules = {members:{Aliases:{type:'list',member:{locationName:'Alias'}}}}
      params = {Aliases:['abc','mno','xyz']}
      xml = """
      <Data xmlns="#{xmlns}">
        <Aliases>
          <Alias>abc</Alias>
          <Alias>mno</Alias>
          <Alias>xyz</Alias>
        </Aliases>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'includes lists elements even if they have no members', ->
      rules = {members:{Aliases:{type:'list',member:{locationName:'Alias'}}}}
      params = {Aliases:[]}
      xml = """
      <Data xmlns="#{xmlns}">
        <Aliases/>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'serializes lists of structures', ->
      rules = members:
        Points:
          type: 'list'
          member:
            type: 'structure'
            locationName: 'Point'
            members:
              X: {type:'float'}
              Y: {type:'float'}
      params = {Points:[{X:1.2,Y:2.1},{X:3.4,Y:4.3}]}
      xml = """
      <Data xmlns="#{xmlns}">
        <Points>
          <Point>
            <X>1.2</X>
            <Y>2.1</Y>
          </Point>
          <Point>
            <X>3.4</X>
            <Y>4.3</Y>
          </Point>
        </Points>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'flattened lists', ->

    it 'serializes lists without a base wrapper', ->
      rules = {members:{Aliases:{type:'list',flattened:true,member:{}}}}
      params = {Aliases:['abc','mno','xyz']}
      xml = """
      <Data xmlns="#{xmlns}">
        <Aliases>abc</Aliases>
        <Aliases>mno</Aliases>
        <Aliases>xyz</Aliases>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'serializes lists (custom member names)', ->
      rules = members: {Aliases:{type:'list',flattened:true,member:{locationName:'Alias'}}}
      params = {Aliases:['abc','mno','xyz']}
      xml = """
      <Data xmlns="#{xmlns}">
        <Alias>abc</Alias>
        <Alias>mno</Alias>
        <Alias>xyz</Alias>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'omits lists elements when no members are given', ->
      rules = {members:{Aliases:{type:'list',flattened:true,member:{locationName:'Alias'}}}}
      params = {Aliases:[]}
      xml = ''
      matchXML(toXML(rules, params), xml)

    it 'serializes lists of structures', ->
      rules = members:
        Points:
          type: 'list'
          flattened: true
          name: 'Point'
          member:
            type: 'structure'
            locationName: 'Point'
            members:
              X: {type:'float'}
              Y: {type:'float'}
      params = {Points:[{X:1.2,Y:2.1},{X:3.4,Y:4.3}]}
      xml = """
      <Data xmlns="#{xmlns}">
        <Point>
          <X>1.2</X>
          <Y>2.1</Y>
        </Point>
        <Point>
          <X>3.4</X>
          <Y>4.3</Y>
        </Point>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'maps', ->
    rules =
      type: 'structure'
      members:
        Items:
          type: 'map'
          key: type: 'string'
          value: type: 'string'

    it 'translates maps', ->
      params = { Items: { A: 'a', B: 'b' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Items>
          <entry>
            <key>A</key>
            <value>a</value>
          </entry>
          <entry>
            <key>B</key>
            <value>b</value>
          </entry>
        </Items>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'allows renamed map keys and values', ->
      params = { Items: { A: 'a', B: 'b' } }
      otherRules =
        type: 'structure'
        members:
          Items:
            type: 'map'
            key: type: 'string', locationName: 'MKEY'
            value: type: 'string', locationName: 'MVALUE'
      xml = """
      <Data xmlns="#{xmlns}">
        <Items>
          <entry>
            <MKEY>A</MKEY>
            <MVALUE>a</MVALUE>
          </entry>
          <entry>
            <MKEY>B</MKEY>
            <MVALUE>b</MVALUE>
          </entry>
        </Items>
      </Data>
      """
      matchXML(toXML(otherRules, params), xml)

    it 'ignores null', ->
      expect(toXML(rules, Items: null)).toEqual('')

    it 'ignores undefined', ->
      expect(toXML(rules, Items: undefined)).toEqual('')

  describe 'flattened maps', ->
    rules =
      type: 'structure'
      members:
        Items:
          type: 'map'
          locationName: 'Item'
          flattened: true
          key: type: 'string'
          value: type: 'string'

    it 'translates flattened maps', ->
      params = { Items: { A: 'a', B: 'b' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Item>
          <key>A</key>
          <value>a</value>
        </Item>
        <Item>
          <key>B</key>
          <value>b</value>
        </Item>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'allows renamed map keys and values', ->
      params = { Items: { A: 'a', B: 'b' } }
      otherRules =
        type: 'structure'
        members:
          Items:
            locationName: 'Item'
            flattened: true
            type: 'map'
            key: type: 'string', locationName: 'MKEY'
            value: type: 'string', locationName: 'MVALUE'
      xml = """
      <Data xmlns="#{xmlns}">
        <Item>
          <MKEY>A</MKEY>
          <MVALUE>a</MVALUE>
        </Item>
        <Item>
          <MKEY>B</MKEY>
          <MVALUE>b</MVALUE>
        </Item>
      </Data>
      """
      matchXML(toXML(otherRules, params), xml)

    it 'ignores null', ->
      expect(toXML(rules, Items: null)).toEqual('')

    it 'ignores undefined', ->
      expect(toXML(rules, Items: undefined)).toEqual('')

  describe 'numbers', ->

    it 'integers', ->
      rules = members: {Count:{type:'integer'}}
      params = { Count: 123.0 }
      xml = """
      <Data xmlns="#{xmlns}">
        <Count>123</Count>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'floats', ->
      rules = members: {Count:{type:'float'}}
      params = { Count: 123.123 }
      xml = """
      <Data xmlns="#{xmlns}">
        <Count>123.123</Count>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'ints and floats formatted as numbers', ->
      rules = members: {CountI:{type:'integer'},CountF:{type:'float'}}
      params = { CountI: '123', CountF: '1.23' }
      xml = """
      <Data xmlns="#{xmlns}">
        <CountI>123</CountI>
        <CountF>1.23</CountF>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'booleans', ->

    it 'true', ->
      rules = members: {Enabled:{type:'boolean'}}
      params = { Enabled: true }
      xml = """
      <Data xmlns="#{xmlns}">
        <Enabled>true</Enabled>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'false', ->
      rules = members: {Enabled:{type:'boolean'}}
      params = { Enabled: false }
      xml = """
      <Data xmlns="#{xmlns}">
        <Enabled>false</Enabled>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'timestamps', ->

    time = new Date()
    time.setMilliseconds(0)

    it 'iso8601', ->
      api.timestampFormat = 'iso8601'
      rules = members: {Expires:{type:'timestamp'}}
      params = { Expires: time }
      xml = """
      <Data xmlns="#{xmlns}">
        <Expires>#{AWS.util.date.iso8601(time)}</Expires>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'rfc822', ->
      api.timestampFormat = 'rfc822'
      rules = members: {Expires:{type:'timestamp'}}
      params = { Expires: time }
      xml = """
      <Data xmlns="#{xmlns}">
        <Expires>#{AWS.util.date.rfc822(time)}</Expires>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'unix timestamp', ->
      api.timestampFormat = 'unixTimestamp'
      rules = members: {Expires:{type:'timestamp'}}
      params = { Expires: time }
      xml = """
      <Data xmlns="#{xmlns}">
        <Expires>#{AWS.util.date.unixTimestamp(time)}</Expires>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'follows the forat given on the shape', ->
      api.timestampFormat = 'unixTimestamp'
      rules = members: {Expires:{type:'timestamp',timestampFormat:'rfc822'}}
      params = { Expires: time }
      # despite the api configuration will specify unixTimesmap, we expect
      # an rfc822 formatted date based on the format attribute
      xml = """
      <Data xmlns="#{xmlns}">
        <Expires>#{AWS.util.date.rfc822(time)}</Expires>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'xml attributes', ->
    it 'can serialize xml attributes', ->
      rules = members:
        Config:
          type: 'structure'
          members:
            Foo:
              type: 'string'
            Attr:
              type: 'string'
              xmlAttribute: true
              locationName: 'attr:name'
      params = { Config: { Foo: 'bar', Attr: 'abc' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config attr:name="abc"><Foo>bar</Foo></Config>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

  describe 'xml namespaces', ->
    it 'can apply xml namespaces on structures', ->
      rules = members:
        Config:
          type: 'structure'
          xmlNamespace:
            uri: 'URI'
          members:
            Foo:
              type: 'string'
      params = { Config: { Foo: 'bar' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config xmlns="URI"><Foo>bar</Foo></Config>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'applies namespace prefixes to the xmlns attribute', ->
      rules = members:
        Config:
          type: 'structure'
          xmlNamespace:
            prefix: 'xsi'
            uri: 'URI'
          members:
            Foo:
              type: 'string'
      params = { Config: { Foo: 'bar' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config xmlns:xsi="URI"><Foo>bar</Foo></Config>
      </Data>
      """
      matchXML(toXML(rules, params), xml)

    it 'can apply namespaces to elements that have other attributes', ->
      rules = members:
        Config:
          type: 'structure'
          xmlNamespace:
            prefix: 'xsi'
            uri: 'URI'
          members:
            Foo:
              type: 'string'
            Bar:
              type: 'string'
              xmlAttribute: true
              locationName: 'xsi:label'
      params = { Config: { Foo: 'abc', Bar: 'xyz' } }
      xml = """
      <Data xmlns="#{xmlns}">
        <Config xmlns:xsi="URI" xsi:label="xyz"><Foo>abc</Foo></Config>
      </Data>
      """
      matchXML(toXML(rules, params), xml)