vendor/github.com/apache/thrift/test/py.twisted/test_suite.py

   1 #!/usr/bin/env python
   2
   3 #
   4 # Licensed to the Apache Software Foundation (ASF) under one
   5 # or more contributor license agreements. See the NOTICE file
   6 # distributed with this work for additional information
   7 # regarding copyright ownership. The ASF licenses this file
   8 # to you under the Apache License, Version 2.0 (the
   9 # "License"); you may not use this file except in compliance
  10 # with the License. You may obtain a copy of the License at
  11 #
  12 #   http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing,
  15 # software distributed under the License is distributed on an
  16 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17 # KIND, either express or implied. See the License for the
  18 # specific language governing permissions and limitations
  19 # under the License.
  20 #
  21
  22 import sys
  23 import os
  24 import glob
  25 import time
  26 basepath = os.path.abspath(os.path.dirname(__file__))
  27 sys.path.insert(0, os.path.join(basepath, 'gen-py.twisted'))
  28 sys.path.insert(0, glob.glob(os.path.join(basepath, '../../lib/py/build/lib.*'))[0])
  29
  30 from ThriftTest import ThriftTest
  31 from ThriftTest.ttypes import Xception, Xtruct
  32 from thrift.transport import TTwisted
  33 from thrift.protocol import TBinaryProtocol
  34
  35 from twisted.trial import unittest
  36 from twisted.internet import defer, reactor
  37 from twisted.internet.protocol import ClientCreator
  38
  39 from zope.interface import implements
  40
  41
  42 class TestHandler:
  43     implements(ThriftTest.Iface)
  44
  45     def __init__(self):
  46         self.onewaysQueue = defer.DeferredQueue()
  47
  48     def testVoid(self):
  49         pass
  50
  51     def testString(self, s):
  52         return s
  53
  54     def testByte(self, b):
  55         return b
  56
  57     def testI16(self, i16):
  58         return i16
  59
  60     def testI32(self, i32):
  61         return i32
  62
  63     def testI64(self, i64):
  64         return i64
  65
  66     def testDouble(self, dub):
  67         return dub
  68
  69     def testBinary(self, thing):
  70         return thing
  71
  72     def testStruct(self, thing):
  73         return thing
  74
  75     def testException(self, s):
  76         if s == 'Xception':
  77             x = Xception()
  78             x.errorCode = 1001
  79             x.message = s
  80             raise x
  81         elif s == "throw_undeclared":
  82             raise ValueError("foo")
  83
  84     def testOneway(self, seconds):
  85         def fireOneway(t):
  86             self.onewaysQueue.put((t, time.time(), seconds))
  87         reactor.callLater(seconds, fireOneway, time.time())
  88
  89     def testNest(self, thing):
  90         return thing
  91
  92     def testMap(self, thing):
  93         return thing
  94
  95     def testSet(self, thing):
  96         return thing
  97
  98     def testList(self, thing):
  99         return thing
 100
 101     def testEnum(self, thing):
 102         return thing
 103
 104     def testTypedef(self, thing):
 105         return thing
 106
 107
 108 class ThriftTestCase(unittest.TestCase):
 109
 110     @defer.inlineCallbacks
 111     def setUp(self):
 112         self.handler = TestHandler()
 113         self.processor = ThriftTest.Processor(self.handler)
 114         self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
 115
 116         self.server = reactor.listenTCP(
 117             0, TTwisted.ThriftServerFactory(self.processor, self.pfactory), interface="127.0.0.1")
 118
 119         self.portNo = self.server.getHost().port
 120
 121         self.txclient = yield ClientCreator(reactor,
 122                                             TTwisted.ThriftClientProtocol,
 123                                             ThriftTest.Client,
 124                                             self.pfactory).connectTCP("127.0.0.1", self.portNo)
 125         self.client = self.txclient.client
 126
 127     @defer.inlineCallbacks
 128     def tearDown(self):
 129         yield self.server.stopListening()
 130         self.txclient.transport.loseConnection()
 131
 132     @defer.inlineCallbacks
 133     def testVoid(self):
 134         self.assertEquals((yield self.client.testVoid()), None)
 135
 136     @defer.inlineCallbacks
 137     def testString(self):
 138         self.assertEquals((yield self.client.testString('Python')), 'Python')
 139
 140     @defer.inlineCallbacks
 141     def testByte(self):
 142         self.assertEquals((yield self.client.testByte(63)), 63)
 143
 144     @defer.inlineCallbacks
 145     def testI32(self):
 146         self.assertEquals((yield self.client.testI32(-1)), -1)
 147         self.assertEquals((yield self.client.testI32(0)), 0)
 148
 149     @defer.inlineCallbacks
 150     def testI64(self):
 151         self.assertEquals((yield self.client.testI64(-34359738368)), -34359738368)
 152
 153     @defer.inlineCallbacks
 154     def testDouble(self):
 155         self.assertEquals((yield self.client.testDouble(-5.235098235)), -5.235098235)
 156
 157     # TODO: def testBinary(self) ...
 158
 159     @defer.inlineCallbacks
 160     def testStruct(self):
 161         x = Xtruct()
 162         x.string_thing = "Zero"
 163         x.byte_thing = 1
 164         x.i32_thing = -3
 165         x.i64_thing = -5
 166         y = yield self.client.testStruct(x)
 167
 168         self.assertEquals(y.string_thing, "Zero")
 169         self.assertEquals(y.byte_thing, 1)
 170         self.assertEquals(y.i32_thing, -3)
 171         self.assertEquals(y.i64_thing, -5)
 172
 173     @defer.inlineCallbacks
 174     def testException(self):
 175         yield self.client.testException('Safe')
 176         try:
 177             yield self.client.testException('Xception')
 178             self.fail("should have gotten exception")
 179         except Xception as x:
 180             self.assertEquals(x.errorCode, 1001)
 181             self.assertEquals(x.message, 'Xception')
 182
 183         try:
 184             yield self.client.testException("throw_undeclared")
 185             self.fail("should have thrown exception")
 186         except Exception:  # type is undefined
 187             pass
 188
 189     @defer.inlineCallbacks
 190     def testOneway(self):
 191         yield self.client.testOneway(1)
 192         start, end, seconds = yield self.handler.onewaysQueue.get()
 193         self.assertAlmostEquals(seconds, (end - start), places=1)