def app(cloud_config, testbed):
main.PROJECTID = cloud_config.project
return webtest.TestApp(main.app)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import unittest
import urlparse
import cloudstorage as gcs
import webtest
import gcs_async
app = webtest.TestApp(None)
def write(path, data):
if not isinstance(data, str):
data = json.dumps(data)
with gcs.open(path, 'w') as f:
f.write(data)
def install_handler_dispatcher(stub, matches, dispatch):
def fetch_stub(url,
payload,
method,
headers,
request,
def setUp(self):
super(TickMonitoringCustomMetricTest, self).setUp()
app = webapp2.WSGIApplication([('/auto_bisect',
auto_bisect.AutoBisectHandler)])
self.testapp = webtest.TestApp(app)
def setUp(self):
self._set_up_gae_testbed()
self.testapp = webtest.TestApp(handlers.app)
def test_app_from_config_file(self):
config = os.path.join(os.path.dirname(__file__), 'deploy.ini')
app = webtest.TestApp('config:%s#main' % config)
resp = app.get('/')
self.assertEqual(resp.status_int, 200)
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
app = webapp2.WSGIApplication([
RedirectRoute(r'/team/<team_number:[0-9]+>', TeamCanonical,
'team-canonical'),
RedirectRoute(r'/team/<team_number:[0-9]+>/<year:[0-9]+>',
TeamDetail, 'team-detail'),
RedirectRoute(r'/team/<team_number:[0-9]+>/history', TeamHistory,
'team-history'),
RedirectRoute(r'/teams/<page:[0-9]+>', TeamList, 'team-list-year'),
RedirectRoute(r'/teams', TeamList, 'team-list'),
])
self.testapp = webtest.TestApp(app)
self.team = Team(
id="frc1124",
name="Really Long Name",
team_number=1124,
rookie_year=2003,
nickname="The UberBots",
city="Avon",
state_prov="CT",
country="USA",
website="www.uberbots.org",
motto="This is a motto",
)
self.event = Event(
id="2016necmp",
name="New England District Championship",
event_type_enum=EventType.DISTRICT_CMP,
short_name="New England",
event_short="necmp",
year=2016,
end_date=datetime(2016, 03, 27),
official=True,
city='Hartford',
state_prov='CT',
country='USA',
venue="Some Venue",
venue_address="Some Venue, Hartford, CT, USA",
timezone_id="America/New_York",
start_date=datetime(2016, 03, 24),
)
self.event_team = EventTeam(id="2016necmp_frc1124",
team=self.team.key,
event=self.event.key,
year=2016)
self.event2 = Event(
id="2015necmp",
name="New England District Championship",
event_type_enum=EventType.DISTRICT_CMP,
short_name="New England",
event_short="necmp",
year=2015,
end_date=datetime(2015, 03, 27),
official=True,
city='Hartford',
state_prov='CT',
country='USA',
venue="Some Venue",
venue_address="Some Venue, Hartford, CT, USA",
timezone_id="America/New_York",
start_date=datetime(2015, 03, 24),
)
self.event_team2 = EventTeam(id="2015necmp_frc1124",
team=self.team.key,
event=self.event2.key,
year=2015)
self.event_team.put()
self.team.put()
self.event.put()
self.event_team.put()
self.event2.put()
self.event_team2.put()
def webapi(app):
return webtest.TestApp(app)
def setUp(self):
self.config = testing.setUp()
self.config.include('example')
self.config.commit()
self.app = webtest.TestApp(self.config.make_wsgi_app())
def setUp(self):
self.app = webtest.TestApp('config:test.ini', relative_to='.')
def setUp(self):
app = webapp2.WSGIApplication([('/(.*)', server.Site)])
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_memcache_stub()
def setUpClass(cls):
cls.app = webtest.TestApp(wsgi.application)
def _trace_app(self, tracer=None):
self.app.install(TracePlugin(service=SERVICE, tracer=tracer))
self.app = webtest.TestApp(self.app)
def setUp(self):
super(GeostoreTest, self).setUp()
self.api = webtest.TestApp(handlers)
def setup_method(self):
"""Tests per method setup."""
self.server = rest_server.BuilderRESTServer()
self.app = webtest.TestApp(self.server)
def testpriv(priv):
return webtest.TestApp(priv)
def client():
return webtest.TestApp(application)
def setUp(self):
super(FerrisAppTest, self).setUp()
import main
reload(main)
self.testapp = webtest.TestApp(main.main_app)
add_custom_parameter(USER_ATTRS[0], 'test_value')
add_custom_parameter(USER_ATTRS[1], 'test_value')
response_headers = [('Content-Type', 'text/html; charset=utf-8'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
try:
raise ValueError('Transaction had bad value')
except ValueError:
record_exception(params={ERROR_PARAMS[0]: 'param-value'})
return [output]
normal_application = webtest.TestApp(normal_wsgi_application)
# Tests for checking the presence and format of agent attributes.
# Test default settings.
_expected_attributes = {
'agent': TRACE_ERROR_AGENT_KEYS,
'user': ERROR_USER_ATTRS,
'intrinsic': ['trip_id']
}
_expected_attributes_event = {
'agent': TRACE_ERROR_AGENT_KEYS,
'user': ERROR_USER_ATTRS,
'intrinsic': ERROR_EVENT_INTRINSICS
}
def setUp(self):
super(EmailSummaryTest, self).setUp()
app = webapp2.WSGIApplication(
[('/email_summary', email_summary.EmailSummaryHandler)])
self.testapp = webtest.TestApp(app)
def setUp(self):
wsgi_app = self._makeWsgiDAVApp(False)
self.app = webtest.TestApp(wsgi_app)
def setUp(self):
super(IpBlacklistModuleTest, self).setUp()
self.testapp = webtest.TestApp(gae_main.app)
def _setup_extensions_test_app(extension_manager=None):
return webtest.TestApp(setup_extensions_middleware(extension_manager))
def test_authentication__no_auth_provided(self):
testapp = webtest.TestApp(links_handlers.app)
response = testapp.get('/_/api/links')
self.assertIn('redirect_to', json.loads(response.body))
def setUp(self):
self.config = testing.setUp()
self.config.include("pyramid_fanstatic")
self.config.add_route('home', '/')
self.config.add_view(route_name='home', view=home)
self.app = webtest.TestApp(self.config.make_wsgi_app())
def setUp(self):
self.app = webtest.TestApp(debug_app)
def setUp(self):
"""Set up and add dummy route to webtest application."""
super(TestCustomConfigUseApplicationUri, self).setUp()
self.config.add_route('dummy', '/subdir/page')
self.config.add_view(route_name='dummy', view=home) # dummy route
self.app = webtest.TestApp(self.config.make_wsgi_app())
def setUp(self, load_sample_data=True, app_conf='keystone'):
"""Setup for v3 Restful Test Cases.
If a child class wants to create their own sample data
and provide their own auth data to obtain tokens, then
load_sample_data should be set to false.
"""
super(RestfulTestCase, self).setUp()
self.config(self.config_files())
self.setup_database()
new_paste_file = self.generate_paste_config()
if new_paste_file:
app_conf = 'config:%s' % (new_paste_file)
# ensure the cache region instance is setup
cache.configure_cache_region(cache.REGION)
self.load_backends()
self.public_app = webtest.TestApp(self.loadapp(app_conf, name='main'))
self.admin_app = webtest.TestApp(self.loadapp(app_conf, name='admin'))
if load_sample_data:
self.domain_id = uuid.uuid4().hex
self.domain = self.new_domain_ref()
self.domain['id'] = self.domain_id
self.assignment_api.create_domain(self.domain_id, self.domain)
self.project_id = uuid.uuid4().hex
self.project = self.new_project_ref(domain_id=self.domain_id)
self.project['id'] = self.project_id
self.assignment_api.create_project(self.project_id, self.project)
self.user_id = uuid.uuid4().hex
self.user = self.new_user_ref(domain_id=self.domain_id)
self.user['id'] = self.user_id
self.identity_api.create_user(self.user_id, self.user)
self.default_domain_project_id = uuid.uuid4().hex
self.default_domain_project = self.new_project_ref(
domain_id=DEFAULT_DOMAIN_ID)
self.default_domain_project['id'] = self.default_domain_project_id
self.assignment_api.create_project(self.default_domain_project_id,
self.default_domain_project)
self.default_domain_user_id = uuid.uuid4().hex
self.default_domain_user = self.new_user_ref(
domain_id=DEFAULT_DOMAIN_ID)
self.default_domain_user['id'] = self.default_domain_user_id
self.identity_api.create_user(self.default_domain_user_id,
self.default_domain_user)
# create & grant policy.json's default role for admin_required
self.role_id = uuid.uuid4().hex
self.role = self.new_role_ref()
self.role['id'] = self.role_id
self.role['name'] = 'admin'
self.assignment_api.create_role(self.role_id, self.role)
self.assignment_api.add_role_to_user_and_project(
self.user_id, self.project_id, self.role_id)
self.assignment_api.add_role_to_user_and_project(
self.default_domain_user_id, self.default_domain_project_id,
self.role_id)
self.assignment_api.add_role_to_user_and_project(
self.default_domain_user_id, self.project_id, self.role_id)
self.service_id = uuid.uuid4().hex
self.service = self.new_service_ref()
self.service['id'] = self.service_id
self.catalog_api.create_service(self.service_id,
self.service.copy())
self.endpoint_id = uuid.uuid4().hex
self.endpoint = self.new_endpoint_ref(service_id=self.service_id)
self.endpoint['id'] = self.endpoint_id
self.catalog_api.create_endpoint(self.endpoint_id,
self.endpoint.copy())
self.public_server = self.serveapp(app_conf, name='main')
self.admin_server = self.serveapp(app_conf, name='admin')
def testapp(app):
"""Return a webtest TestApp initiated with pypiserver app"""
bottle.debug(True)
return webtest.TestApp(app)
def setUp(self):
super(TestNamespaceDatastoreSample, self).setUp()
self.app = webtest.TestApp(datastore.app)
def setUp(self):
super(MainTest, self).setUp()
app = webapp2.WSGIApplication([('/', main.MainHandler)])
self.testapp = webtest.TestApp(app)
