def init_app_basics(self, init_topics=False):
from models import User, Topic
from constants import API_AUTH, TOPIC
self.user1 = User.Create(email="*****@*****.**",
phone="254729465000")
self.user2 = User.Create(email="*****@*****.**",
phone="254729465999")
ndb.put_multi([self.user1, self.user2])
if init_topics:
# 4 topics, politics is a poll
self.topics = []
ndb_put = []
for topic_name in ["health", "matatus", "politics", "rain"]:
t = Topic.Create()
t.Update(name=topic_name, status=TOPIC.LIVE)
if topic_name == "politics":
t.Update(poll=True, poll_choices=["Hillary", "Donald"])
ndb_put.append(t)
self.topics.append(t)
ndb.put_multi(ndb_put)
# Setup API authentication params for use in API calls
self.api_auth_params = {'auth': API_AUTH}
def testLookupDicts(self):
user1 = User.Create(email="*****@*****.**", name="Person 1")
user1.put()
user2 = User.Create(email="*****@*****.**", name="Person 2")
user2.put()
lookup = tools.lookupDict([user1, user2], keyprop="key_string")
u1_key = user1.key.urlsafe()
u2_key = user2.key.urlsafe()
self.assertTrue(u1_key in lookup)
self.assertTrue(u2_key in lookup)
self.assertEqual(lookup.get(u1_key).name, "Person 1")
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_app_identity_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_blobstore_stub()
self.init_modules_stub()
cloudstorage.set_default_retry_params(None)
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {'speed': {'unit': 'kph'}, 'narrative': {'type': 'string'}}
self.spedometer.Update(name="Spedometer", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1")
self.vehicle_1.put()
def testUserGoogleSimpleAccountLinking(self):
import jwt
user = User.Create(email="*****@*****.**", g_id=USER_GOOGLE_ID)
user.put()
creation = int(tools.unixtime(ms=False))
payload = {
'iss': 'https://accounts.google.com',
'aud': secrets.GOOGLE_CLIENT_ID,
'sub': USER_GOOGLE_ID,
'email': "*****@*****.**",
'locale': "en_US",
"iat": creation,
"exp": creation + 60 * 60
}
params = {
'grant_type':
'urn:ietf:params:oauth:grant-type:jwt-bearer',
'intent':
'get',
'assertion':
jwt.encode(payload,
secrets.GOOGLE_CLIENT_SECRET,
algorithm='HS256')
}
response = self.post_json("/api/auth/google/token", params)
token_type = response.get('token_type')
self.assertEqual(token_type, 'bearer')
def testCloneEntity(self):
user = User.Create(email="*****@*****.**", name="John Doe")
user.put()
user_cloned = tools.clone_entity(user)
self.assertEqual(user.name, user_cloned.name)
self.assertEqual(user.email, user_cloned.email)
def testUserAccessEncodeDecode(self):
user = User.Create(email="*****@*****.**")
user.put()
access_token = user.aes_access_token(client_id="test")
user_id = User.user_id_from_aes_access_token(access_token)
self.assertIsNotNone(access_token)
self.assertEqual(user_id, user.key.id())
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.register_search_api_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", alias=E_ALIAS.upper())
self.e.put()
self.u = User.Create(self.e, phone=TEST_NUM, email=TEST_EMAIL)
self.u.Update(password=PW, level=USER.ACCOUNT_ADMIN)
self.u.put()
self.st = SensorType.Create(self.e)
self.st.Update(alias="geo",
schema=json.dumps({'location': {
'type': 'location'
}}))
self.st.put()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_standard_stubs()
u = User.Create(email="*****@*****.**")
u.put()
self.u = u
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {
'speed': {
'unit': 'kph'
},
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'degrees'
},
'hard_braking': {
'unit': 'boolean'
}
}
self.spedometer.Update(name="Geo Sensor", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
# Create alarm
self.speeding_alarm = Rule.Create(self.e)
self.speeding_alarm.Update(name="Speeding",
sensortype_id=self.spedometer.key().id(),
column="speed",
trigger=RULE.CEILING,
value2=80.0,
alert_contacts=["owner"],
alert_message=SPEEDING_ALERT_MESSAGE,
duration=0)
self.speeding_alarm.put()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
u = User.Create(email="*****@*****.**")
u.put()
self.u = u
def init_app_basics(self, n_users=1):
from models import User
self.users = []
for x in range(n_users):
email = "*****@*****.**" % (tools.GenPasswd())
user = User.Create(email=email)
user.setPass("pw")
user.put()
self.users.append(user)
# Setup API authentication params for use in API calls
if n_users:
encoded = base64.b64encode("%s:%s" %
(self.users[0].key.id(), "pw"))
self.api_headers = {'authorization': "Basic %s" % encoded}
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
u = User.Create(email="*****@*****.**")
u.put()
self.project = Project.Create(u)
self.project.Update(title="Build App",
subhead="Subhead",
urls=["http://www.example.com"])
self.project.put()
def google_login(self):
from constants import ADMIN_EMAIL
token = self.request.get('token')
ok, _email, name = self.validate_google_id_token(token)
u = None
if ok:
u = User.GetByEmail(_email)
if not u:
u = User.Create(email=_email, name=name)
u.put()
if u:
self.update_session_user(u)
self.login_dt = datetime.now()
self.success = True
self.message = "Signed in"
else:
self.message = "Failed to validate"
self.set_response({'user': u.json() if u else None})
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.tracker = SensorType.Create(self.e)
schema = {
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION],
'type': 'latlng'
}
}
self.tracker.Update(name="Geo Sensor", schema=json.dumps(schema))
self.tracker.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.tracker.key().id())
self.vehicle_1.Update(sensortype_id=self.tracker.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
def post(self):
self.template_values['page_name'] = 'signin'
signup_data = dict(self.request.POST)
# {u'_token': u'', u'username': u'jacobcui', u'password_confirmation': u'qwqq', u'g-recaptcha-response': u'', u'password': u'qwqq'}
if not self.verify_recaptcha():
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
'Please check reCAPTCHA input.'
})
human_verified = False
else:
human_verified = True
for field in ['username', 'password', 'password_confirmation']:
value = signup_data.get(field, '').strip()
if not value:
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
("{} can't be empty.".format(field.capitalize().replace(
'_', ' ')))
})
if len(signup_data.get('password', '')) < 4:
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
'Please ensure password is longer than 4 characters.'
})
if (signup_data.get('password', '') != signup_data.get(
'password_confirmation', '')):
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
'Please ensure passwords are the same.'
})
if not User.validate_username(signup_data.get('username', '')):
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
'Please input valid username. Letters, Numbers, -, _ are allowed.'
})
if human_verified and User.getByUsername(
signup_data.get('username', '')):
self.template_values['alerts'].append({
'class':
views.ALERT_CLASS_WARNING,
'content':
'User with username {} has been registered.'.format(
signup_data.get('username'))
})
if self.template_values['alerts']:
self.template_values.update(signup_data)
self.send_response('signup.html')
return
username = signup_data.get('username').strip()
# Create user
self.user = User.Create(username=username,
password=signup_data.get('password'))
self.init_new_session(username)
self.redirect('/')
