def test_parameter(self):
        """ Parameter -> Parameter
        """
        # body
        o = self.app.root.paths['/api/pet/{petId}'].patch
        p = [p for p in o.parameters if getattr(p, 'in') == 'body'][0]
        self.assertEqual(getattr(p, 'in'), 'body')
        self.assertEqual(p.required, True)
        self.assertEqual(getattr(p.schema, '$ref'), _pf('/definitions/pet!##!Pet'))

        # form
        o = self.app.root.paths['/api/pet/uploadImage'].post
        p = [p for p in o.parameters if getattr(p, 'in') == 'formData' and p.type == 'string'][0]
        self.assertEqual(p.name, 'additionalMetadata')
        self.assertEqual(p.required, False)

        # file
        o = self.app.root.paths['/api/pet/uploadImage'].post
        p = [p for p in o.parameters if getattr(p, 'in') == 'formData' and p.type == 'file'][0]
        self.assertEqual(p.name, 'file')
        self.assertEqual(p.required, False)

        # non-body can't have $ref
        try:
            App._create_(get_test_data_folder(
                version='1.2',
                which='upgrade_parameter'
            ))
        except errs.SchemaError as e:
            self.failUnlessEqual(e.args, ("Can't have $ref in non-body Parameters",))
        else:
            self.fail('SchemaError not raised')

    def test_dict_getter_v2_0(self):
        """ make sure 'DictGetter' works the same as 'LocalGetter'
        for Swagger 2.0
        """

        #
        # loading via DictGetter
        #
        path = get_test_data_folder(
            version='2.0',
            which='wordnik'
        )

        origin_app = App.create(path)

        with open(os.path.join(path, 'swagger.json'), 'r') as f:
            spec = json.loads(f.read())

        getter = DictGetter([path], {
            os.path.join(path, 'swagger.json'): spec
        })
        app = App.load(path, resolver=Resolver(default_getter=getter))
        app.prepare()

        # make sure it produce the same App in default way
        self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump())), [])

        #
        # loading via wrong path, should be ok when all internal $ref are not absoluted
        #
        getter = DictGetter([''], {
            '': spec
        })
        app = App.load('', resolver=Resolver(default_getter=getter))
        app.prepare()

        # make sure it produce the same App in default way
        self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])), [])

        #
        # faking http path
        #
        getter = DictGetter(['https://petstore.com'], {
            'https://petstore.com': spec
        })
        app = App.load('https://petstore.com', resolver=Resolver(default_getter=getter))
        app.prepare()

        # make sure it produce the same App in default way
        self.assertEqual(sorted(_diff_(app.dump(), origin_app.dump(), exclude=['$ref'])), [])

    def test_load(self):
        """ make sure the result of yaml and json are identical """
        app_json = App.load(get_test_data_folder(
            version='2.0',
            which='wordnik'
        ))
        app_yaml = App.load(get_test_data_folder(
            version='2.0',
            which='yaml',
            )
        )
        s = Scanner(app_yaml)
        s.scan(route=[YamlFixer()], root=app_yaml.raw, leaves=[Operation])

        self.assertEqual((True, ''), app_json.raw.compare(app_yaml.raw))

    def test_schema(self):
        folder = utils.normalize_url(get_test_data_folder(
            version='2.0',
            which=os.path.join('circular', 'schema')
        ))

        def _pf(s):
            return folder + '#' + s


        app = App.load(folder)
        app.prepare(strict=False)

        s = Scanner(app)
        c = CycleDetector()
        s.scan(root=app.raw, route=[c])
        self.maxDiff = None
        self.assertEqual(sorted(c.cycles['schema']), sorted([
            [_pf('/definitions/s10'), _pf('/definitions/s11'), _pf('/definitions/s9'), _pf('/definitions/s10')],
            [_pf('/definitions/s5'), _pf('/definitions/s5')],
            [_pf('/definitions/s1'), _pf('/definitions/s2'), _pf('/definitions/s3'), _pf('/definitions/s4'), _pf('/definitions/s1')],
            [_pf('/definitions/s12'), _pf('/definitions/s13'), _pf('/definitions/s12')],
            [_pf('/definitions/s6'), _pf('/definitions/s7'), _pf('/definitions/s6')],
            [_pf('/definitions/s14'), _pf('/definitions/s15'), _pf('/definitions/s14')]
        ]))

    def test_float_dump(self):
        """ failed to dump an object with float property

        refer to issue: https://github.com/mission-liao/pyswagger/issues/92
        """
        app = App.create(get_test_data_folder(version='2.0', which=os.path.join('schema', 'floatDump')))
        app.dump() # should not raise exception

    def test_authorization(self):
        """
        """
        app = App.create(get_test_data_folder(
            version='1.2', which='simple_auth')
        )

        expect = {
            'type':'apiKey',
            'in':'query',
            'name':'simpleQK'
        }
        self.assertEqual(_diff_(
            expect,
            app.resolve('#/securityDefinitions/simple_key').dump()
        ), [])

        expect = {
            'type':'apiKey',
            'in':'header',
            'name':'simpleHK'
        }
        self.assertEqual(_diff_(
            expect,
            app.resolve('#/securityDefinitions/simple_key2').dump()
        ), [])


        expect = {
            'type':'basic',
        }
        self.assertEqual(_diff_(
            expect,
            app.resolve('#/securityDefinitions/simple_basic').dump()
        ), [])

    def setUpClass(kls):
        kls.app = App.load(get_test_data_folder(
            version='1.2', which='wordnik'), sep=':'
        )
        kls.app.prepare()

        with open('./test.json', 'w') as r:
            r.write(json.dumps(kls.app.dump(), indent=3))

    def test_path_item_prepare_with_cycle(self):
        app = App.load(get_test_data_folder(
            version='2.0',
            which=os.path.join('circular', 'path_item')
        ))

        # should raise nothing
        app.prepare()

    def setUpClass(kls):
        kls.app = App.load(get_test_data_folder(
            version='2.0',
            which='bitbucket'
        ))

        # bypass cyclic testing
        kls.app.prepare(strict=False)

 def test_relative_schema(self):
     """ test case for issue#53,
     relative file, which root is a Schema Object
     """
     app = App.load(
         url='file:///relative/internal.yaml',
         url_load_hook=_gen_hook(get_test_data_folder(version='2.0', which='ex'))
     )
     app.prepare()

    def test_primfactory(self):
        app = App.create(get_test_data_folder(
            version='2.0',
            which=os.path.join('circular', 'schema'),
            ),
            strict=False
        )

        s = app.resolve('#/definitions/s1')
        self.assertRaises(errs.CycleDetectionError, app.prim_factory.produce, s, {})

 def test_random_name_v1_2(self):
     """
     """
     path = get_test_data_folder(
         version='1.2',
         which='random_file_name'
     )
     path = os.path.join(path, 'test_random.json')
     # should not raise ValueError
     app = App.create(path)

    def test_deref(self):
        app = App.create(get_test_data_folder(
            version='2.0',
            which=os.path.join('circular', 'schema'),
            ),
            strict=False
        )

        s = app.resolve('#/definitions/s1')
        self.assertRaises(errs.CycleDetectionError, utils.deref, s)

 def test_read_only_and_required(self):
     """ a property is both read-only and required """
     app = App.load(get_test_data_folder(
         version='2.0',
         which=os.path.join('validate', 'req_and_readonly')
     ))
     errs = app.validate(strict=False)
     self.maxDiff = None
     self.assertEqual(sorted(errs), sorted([
         ((u'#/definitions/ReadOnly', 'Schema'), 'ReadOnly property in required list: protected')
     ]))

    def test_no_host_basePath(self):
        """ test case for swagger.json without
        'host' and 'basePath' defined
        """
        path = get_test_data_folder(
            version='2.0',
            which=os.path.join('patch', 'no_host_schemes')
        )
        fu = utils.normalize_url(path) # file uri version of path

        # load swagger.json from a file path
        app = App.create(path)
        req, _ = app.s('t1').get()
        self.assertEqual(req.url, '//localhost/t1')
        self.assertEqual(req.schemes, ['file'])
        req.prepare(scheme='file', handle_files=False)
        self.assertEqual(req.url, 'file://localhost/t1')

        # load swagger.json from a file uri
        self.assertNotEqual(six.moves.urllib.parse.urlparse(fu).scheme, '')
        app = App.create(fu)
        req, _ = app.s('t1').get()
        self.assertEqual(req.url, '//localhost/t1')
        self.assertEqual(req.schemes, ['file'])
        req.prepare(scheme='file', handle_files=False)
        self.assertEqual(req.url, 'file://localhost/t1')

        # load swagger.json from a remote uri
        def _hook(url):
            # no matter what url, return the path of local swagger.json
            return fu

        url = 'test.com/api/v1'
        app = App.load('https://'+url, url_load_hook=_hook)
        app.prepare()
        # try to make a Request and verify its url
        req, _ = app.s('t1').get()
        self.assertEqual(req.url, '//test.com/t1')
        self.assertEqual(req.schemes, ['https'])
        req.prepare(scheme='https', handle_files=False)
        self.assertEqual(req.url, 'https://test.com/t1')

    def setUp(self):
        folder = get_test_data_folder(
            version='1.2',
        )

        def _hook(url):
            # a demo of hooking a remote url to local path
            p = six.moves.urllib.parse.urlparse(url)
            return utils.normalize_url(os.path.join(folder, p.path[1:]))

        self.app = App.load('http://petstore.io/wordnik', url_load_hook=_hook)
        self.app.prepare()

    def test_item(self):
        """ make sure to raise exception for invalid item
        """
        try:
            App._create_(get_test_data_folder(
                version='1.2',
                which=os.path.join('upgrade_items', 'with_ref')
            ))
        except errs.SchemaError as e:
            self.failUnlessEqual(e.args, ('Can\'t have $ref for Items',))
        else:
            self.fail('SchemaError not raised')

        try:
            App._create_(get_test_data_folder(
                version='1.2',
                which=os.path.join('upgrade_items', 'invalid_primitive')
            ))
        except errs.SchemaError as e:
            self.failUnlessEqual(e.args, ('Non primitive type is not allowed for Items',))
        else:
            self.fail('SchemaError not raised')

    def test_local_path_with_custome_getter(self):
        """ make sure path would be assigned when
        passing a getter class
        """
        cls = UrlGetter
        path = get_test_data_folder(
            version='2.0',
            which='random_file_name'
        )
        path = os.path.join(path, 'test_random.json')

        # should not raise errors
        app = App.load(path, getter=cls)

    def test_overwrite(self):
        """ overrite type/format handler used in pyswagger """
        m1 = self.app.resolve('#/definitions/m1')
        v = m1._prim_({
            "job":"man"
        }, self.app.prim_factory)
        # should not raise
        self.assertEqual(v.job, "man")

        app = App.create(get_test_data_folder(
            version='2.0',
            which=os.path.join('schema', 'extension')
        ))
        m1 = app.resolve('#/definitions/m1')
        self.assertRaises(errs.ValidationError, m1._prim_, {'job':'man'}, app.prim_factory)

    def test_cookie(self):
        global cookie_cache

        app = App.create(get_test_data_folder(
            version='2.0',
            which=os.path.join('io', 'cookie')
        ))
        client = Webapp2TestClient(cookie_app, keep_cookie=True)
        resp = client.request(app.op['get_cookie']())
        self.assertEqual(resp.status, 200)

        resp = client.request(app.op['keep_cookie']())
        self.assertEqual(resp.status, 200)

        self.assertEqual(cookie_cache, 'test 123')