def test_ballot_measures_extra(self):
with test_database(test_db, [Race,]):
data.load_races('data/tests/init_races.json')
data.load_ballot_measures_extra('data/ballot-measures-extra.csv', quiet=True)
race = Race.get(Race.race_id == '27456-MO')
self.assertEqual(race.ballot_measure_description, 'Teacher performance evaluation (Amendment 3)')
def test_handle(self, bot, test_db, tguser, updater, update, gratitude_states):
"""Test the handle that collects records from the user."""
with test_database(test_db, [User, Record, Job], fail_silently=True):
user, created = User.tg_get_or_create(tguser)
user.active_coach = Gratitude.NAME
user.state = gratitude_states[0]
if user.state == Gratitude.AWAITING_REASONS:
# If no gratitude exists, no reaction can be recorded
if len(gratitude_states[1]) == 0:
return
# Last gratitude must always miss the reaction in 2nd state
gratitude_states[1][-1].reaction = None
with test_db.transaction():
for g in gratitude_states[1]:
g.save()
user.save()
g = Gratitude(bot, test_db, tguser, updater.job_queue)
g.handle(update)
# Reload from disk
g = Gratitude(bot, test_db, tguser, updater.job_queue)
user = User.get(User.id == g.user.id)
if user.state == Gratitude.AWAITING_GRATITUDE:
if len(gratitude_states[1]) < 3:
assert len(g.collector) == len(gratitude_states[1]) + 1
def test_logout_page(self):
"""Test for a 200 status code from our logout route"""
with test_database(self.TEST_DB, (User,)):
rv = self.app.get('/logout')
self.assertEqual(rv.status_code, 302)
with self.app.session_transaction() as sess:
assert 'user_id' not in sess
def test_change_password(self):
with test_database(TEST_DB, (Users,)):
self.create_user()
self.login('root', 'password')
rv = self.change_password('password', 'Pa55_WorD2', 'Pa55_WorD2')
self.assertEqual(rv.status_code, 302)
self.assertEqual(rv.location, 'http://localhost/my-profile')
def test_senate_extra(self):
with test_database(test_db, [Race,]):
data.load_races('data/tests/init_races.json')
data.load_senate_extra('data/senate-extra.csv', quiet=True)
race = Race.get(Race.race_id == '38145-OK')
self.assertEqual(race.previous_party, 'gop')
def test_update_results(self):
with test_database(test_db, [Race, Candidate]):
data.load_races('data/tests/init_races.json')
data.load_candidates('data/tests/init_candidates.json')
data.load_updates('data/tests/update.json')
race = Race.get(Race.race_id == '38529-OR')
candidate_4848 = Candidate.get(Candidate.candidate_id == '4848-OR')
candidate_4642 = Candidate.get(Candidate.candidate_id == '4642-OR')
candidate_4979 = Candidate.get(Candidate.candidate_id == '4979-OR')
self.assertEqual(race.precincts_reporting, 1970)
self.assertEqual(race.precincts_total, 2288)
self.assertTrue(race.is_reporting())
self.assertEqual(candidate_4848.vote_count, 150000)
self.assertEqual(candidate_4642.vote_count, 200000)
self.assertEqual(candidate_4979.vote_count, 250000)
self.assertEqual(race.count_votes(), 600000)
self.assertEqual(candidate_4848.vote_percent(), Decimal('25.0'))
self.assertAlmostEqual(candidate_4642.vote_percent(), Decimal('33.333'), 3)
self.assertAlmostEqual(candidate_4979.vote_percent(), Decimal('41.667'), 3)
# Results does not call races
self.assertFalse(candidate_4848.ap_winner)
self.assertFalse(candidate_4642.ap_winner)
self.assertFalse(candidate_4979.ap_winner)
def test_admin_required(self):
with test_database(TEST_DB, (Users,)):
self.create_user(admin=False)
self.login('root', 'password')
self.register_user()
rv = self.check_admin()
self.assertEqual(rv.status_code, 401)
def test_check_file_size_needed(self):
"""test that the file size returned from the archive is parsed right"""
with test_database(SqliteDatabase(':memory:'), (Cart, File)):
response = """{
"bytes_per_level": "(24L, 0L, 0L, 0L, 0L)",
"ctime": "1444938166",
"file": "/myemsl-dev/bundle/file.1",
"file_storage_media": "disk",
"filesize": "24",
"message": "File was found",
"mtime": "1444938166"
}"""
test_cart = Cart.create(cart_uid='1', status="staging")
test_file = File.create(cart=test_cart, file_name="1.txt",
bundle_path="/tmp/1/1.txt")
cart_utils = Cartutils()
file_size = cart_utils.check_file_size_needed(response, test_file,
test_cart)
self.assertEqual(file_size, 24)
self.assertNotEqual(test_file.status, "error")
#now check for an error by sending a bad response
file_size = cart_utils.check_file_size_needed("", test_file,
test_cart)
self.assertEqual(file_size, -1)
self.assertEqual(test_file.status, "error")
def test_rendering(self):
"""レンダリングが正常に完了していること
"""
index = self.getOne()
with test_database(test_db, (Greeting,)):
html = index()
self.assertTrue(len(html) > 0)
def test_load_success(self):
"""呼び出しが正常に完了して、結果が空になること
"""
with test_database(test_db, (Greeting,)):
load_data = self.getOne()
greeting_list = list(load_data())
self.assertEqual(greeting_list, [])
def test_my_profile(self):
with test_database(TEST_DB, (Users,)):
self.create_user()
self.login('root', 'password')
rv = self.app.get('/my-profile')
self.assertEqual(rv.status_code, 200)
self.assertIn("update profile" , rv.get_data(as_text=True).lower())
def raise_exc():
with test_database(db2, (Data, DataItem), create_tables=False):
self.assertUsing('db2')
Data.create_table()
c = Data.create(key='c')
# This will raise Data.DoesNotExist.
Data.get(Data.key == 'a')
def test_logged_in_menu(self):
with test_database(TEST_DB, (User,)):
UserModelTestCase.create_users(1)
self.app.post('/login', data=USER_DATA)
rv = self.app.get('/')
self.assertIn("add a new taco", rv.get_data(as_text=True).lower())
self.assertIn("log out", rv.get_data(as_text=True).lower())
def test_registration(self):
with test_database(TEST_DB, (Users,)):
self.create_user()
self.login('root', 'password')
rv = self.register_user()
self.assertEqual(rv.status_code, 200)
self.assertIn("user has been created.", rv.get_data(as_text=True).lower())
def test_bad_username(self):
"""Test username error through our POST route"""
self.data['username'] = '******'
with test_database(self.TEST_DB, (User,)):
rv = self.app.post('/register', data=self.data)
self.assertEqual(User.select().count(), 0)
self.assertEqual(rv.status_code, 200)
def test_bad_email(self):
"""Test email error through our POST route"""
self.data['email'] = 'noatsymbolordomain'
with test_database(self.TEST_DB, (User,)):
rv = self.app.post('/register', data=self.data)
self.assertEqual(User.select().count(), 0)
self.assertEqual(rv.status_code, 200)
def test_logout(self):
with test_database(TEST_DB, (Users,)):
self.create_user()
self.login('root', 'password')
rv = self.app.get('/logout')
self.assertEqual(rv.status_code, 302)
self.assertEqual(rv.location, 'http://localhost/login')
def test_post_todo_unauthorized(self):
data = {
'name': 'Feed the dog',
}
with test_database(TEST_DB, (models.User, models.Todo)):
rv = self.app.post('/api/v1/todos', data=data)
self.assertEqual(rv.status_code, 401)
def test_login_page(self):
"""Test for a 200 status code from our registration's GET route"""
with test_database(self.TEST_DB, (User,)):
rv = self.app.get('/login')
self.assertIn("username", rv.get_data(as_text=True).lower())
self.assertIn("password", rv.get_data(as_text=True).lower())
self.assertEqual(rv.status_code, 200)
def test_set_admin(self):
with test_database(TEST_DB, (Users,)):
self.create_user()
self.login('root', 'password')
self.register_user()
rv = self.set_user_admin(id=2)
self.assertIn("user is now an admin." , rv.get_data(as_text=True).lower())
def test_get_counters_returns_correct_values(self):
"""Correct counter values are returned from the database."""
with test_database(self.db, [Counter], create_tables=True):
for k, v in self.test_counters.items():
Counter.create(name=k, count=v)
mh = self.message_handler.get_counters()
self.assertDictEqual(mh['counters'], self.test_counters)
def test_bad_password_confirmation(self):
"""Test password confirmation error through our POST route"""
self.data['password2'] = 'notpassword1'
with test_database(self.TEST_DB, (User,)):
rv = self.app.post('/register', data=self.data)
self.assertEqual(User.select().count(), 0)
self.assertEqual(rv.status_code, 200)
def test_user_automatic_join_date():
with test_database(TEST_DB, [User, Question, Answer]):
create_data()
users = User.select().where(User.join_date == datetime.date.today())
user = users.get()
assert_equal(users.count(), 2)
assert_equal(user.join_date, datetime.date.today())
def test_taco_create(self):
taco_data = {
'protein': 'chicken',
'shell': 'flour',
'cheese': False,
'extras': 'Gimme some guac.'
}
with test_database(TEST_DB, (User, Taco)):
UserModelTestCase.create_users(1)
self.app.post('/login', data=USER_DATA)
taco_data['user'] = User.select().get()
rv = self.app.post('/taco', data=taco_data)
self.assertEqual(rv.status_code, 302)
self.assertEqual(rv.location, 'http://localhost/')
self.assertEqual(Taco.select().count(), 1)
def test_taco_list(self):
taco_data = {
'protein': 'chicken',
'shell': 'flour',
'cheese': False,
'extras': 'Gimme some guac.'
}
with test_database(TEST_DB, (User, Taco)):
UserModelTestCase.create_users(1)
taco_data['user'] = User.select().get()
Taco.create(**taco_data)
rv = self.app.get('/')
self.assertNotIn('no tacos yet', rv.get_data(as_text=True))
self.assertIn(taco_data['extras'], rv.get_data(as_text=True))
def test_edit_entry(self):
with test_database(TEST_DB, (work_log.Entry,)):
entry = work_log.Entry.create(**ENTRIES[0])
with unittest.mock.patch('builtins.input',
side_effect=["u", "Tatiana"]):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.name, "Tatiana")
with unittest.mock.patch('builtins.input',
side_effect=["t", "10 m"]):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.time_spent, 10)
with unittest.mock.patch('builtins.input',
side_effect=["o"]):
with unittest.mock.patch('sys.stdin.read',
return_value="hard work"):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.notes, "hard work")
with unittest.mock.patch('builtins.input',
side_effect=["d", "22.06.2016"]):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.date, datetime.date(2016, 6, 22))
with unittest.mock.patch('builtins.input',
side_effect=["p", "Project"]):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.project, "Project")
with unittest.mock.patch('builtins.input',
side_effect=["n", "Task"]):
work_log.edit_entry(entry=entry)
self.assertEqual(entry.task_name, "Task")
def test_index_update(self):
"""
test return and update of unique index
"""
with test_database(SqliteDatabase(':memory:'), [UniqueIndex]):
test_object = UniqueIndex.create(idid='file', index=892)
self.assertEqual(test_object.idid, 'file')
index, index_range = update_index(10, 'file')
self.assertEqual(index, 892)
self.assertEqual(index_range, 10)
index, index_range = update_index(10, 'file')
self.assertEqual(index, 902)
self.assertEqual(index_range, 10)
index, index_range = update_index(10, 'new')
self.assertEqual(index, 0)
self.assertEqual(index_range, 10)
index, index_range = update_index(10, 'new')
self.assertEqual(index, 10)
self.assertEqual(index_range, 10)
index, index_range = update_index(None, 'new')
self.assertEqual(index, -1)
self.assertEqual(index_range, -1)
index, index_range = update_index(2, None)
self.assertEqual(index, -1)
self.assertEqual(index_range, -1)
index, index_range = update_index(-5, 'new')
self.assertEqual(index, -1)
self.assertEqual(index_range, -1)
def test_question_creation():
with test_database(TEST_DB, [User, Question, Answer]):
create_data()
questions = Question.select()
question = questions.where(Question.text == 'text_0_0').get()
assert_equal(questions.count(), 4)
assert_equal(question.user.email, '*****@*****.**')
def test_creating_article(self):
with test_database(db, (Users, Articles)):
user1 = Users.create_user(username = "******", password = "******")
article = Articles.create_article(title = "test",\
body = "test",\
draft = True,\
author = user1)
self.assertEquals("test", article.title)
self.assertEquals("konrad",article.author.username)
Articles.create_article(title = "test2",\
body = "test",\
draft = False, \
author = user1)
self.assertRaises(IntegrityError,\
lambda: Articles.create_article(title = "test",\
body = "test",\
author = user1))
articles = Articles.get_user_articles("konrad")
self.assertEquals(2,len(tuple(articles)))
user2 = Users.create_user(username = "******", password = "******")
Articles.create_article(title = "test3", \
body = "test",\
author = user2)
articles = Articles.get_user_articles("konrad")
self.assertEquals(2,len(tuple(articles)))
articles2 = Articles.get_user_articles("malgosia")
self.assertEquals(1,len(tuple(articles2)))
def test_get_todos(self):
with test_database(TEST_DB, (Todo,)):
self.create_todos()
rv = self.app.get('/api/v1/todos')
self.assertEqual(rv.status_code, 200)
self.assertEqual(Todo.select().count(), 3)
self.assertIn('Study', rv.get_data(as_text=True))
def test_create_student(self):
with test_database(TEST_DB, (Student,)):
self.create_students(),
self.assertEqual(Student.select().count(), 2)
self.assertNotEqual(
Student.select().get().password, 'password'
)
def test_search_entries(self):
with test_database(TEST_DB, (Entry,)):
self.create_entries()
with mock.patch('builtins.input', side_effect=["a", "Mike", "e"]):
self.assertTrue(worklog_db.search_entries())
with mock.patch('builtins.input', side_effect=["b", "2017-07-12", "e"]):
self.assertTrue(worklog_db.search_entries())
with mock.patch('builtins.input', side_effect=["c", 13, "e"]):
self.assertTrue(worklog_db.search_entries())
with mock.patch('builtins.input',side_effect=["a", ".", "y", "e"]):
self.assertEqual(worklog_db.search_entries(), None)
with mock.patch('builtins.input', side_effect=["d", "Servicing Bikes", "e"]):
self.assertTrue(worklog_db.search_entries())
def test_sort_locations_by_datetime(self):
"""
Test that position numbers are re-assigned according to datetime sort order.
Updates not written to test database.
"""
n_expected = len(self.expected_position_assignments)
with test_database(self.test_db, self.test_tables):
self._load_up_test_location_data()
locations = FishingLocations.select()
self.assertEqual(n_expected, len(locations))
# ----
sorted_locations = ObserverFishingLocations._resequence_orm_location_positions(locations)
# ----
self.assertEqual(n_expected, len(sorted_locations))
for sloc in sorted_locations:
print("{0} {1} ({2:0>5})".format(sloc.position, sloc.location_date, sloc.fishing_location))
self.assertEqual(self.expected_position_assignments[sloc.fishing_location], sloc.position)
def test_diary_entry(self, bot, test_db, tguser, updater):
"""Test diary entry from main menu."""
diary_entry = "My secret diary."
with test_database(test_db, [User, Record], fail_silently=True):
with db.transaction():
user, created = User.tg_get_or_create(tguser)
user.state = Menu.AWAITING_DIARY_ENTRY
user.save()
coach = Menu(bot, db, tguser, updater.job_queue)
msgs = coach.handle(custom_update(msg=diary_entry))
assert len(msgs) == 1
rec = Record.get(Record.content == diary_entry)
assert isinstance(rec, Record)
def test_job_subcommand(self):
"""Test the job subcommand for updating job state."""
rwfd, fname = mkstemp()
os.close(rwfd)
with test_database(SqliteDatabase(fname), (BaseModel, IngestState)):
IngestState.create(job_id=999,
state='ERROR',
task='unbundling',
task_percent=42.3)
IngestState.database_close()
cmd([
'job', '--task=unbundling', '--job-id=999', '--state=OK',
'--task-percent=100.0', '--exception=Badness'
])
record = read_state(999)
self.assertEqual(record.state, 'OK')
self.assertEqual(record.task_percent, 100.0)
def base_where_clause(self, obj_hash):
"""
Base where clause checking.
create a new object from the obj_hash
save it to the database
check all keys in obj_hash separately
query a new object using that key and value in obj_hash
compare the pulled object hash with obj_hash
"""
with test_database(SqliteDatabase(':memory:'), self.dependent_cls()):
obj = self.base_create_obj(self.obj_cls, obj_hash)
for (key, val) in obj_hash.iteritems():
chk_obj = self.base_where_clause_search(obj, {key: val})[0]
chk_obj_hash = chk_obj.to_hash()
for chkkey in obj_hash.keys():
self.assertEqual(chk_obj_hash[chkkey], obj_hash[chkkey])
def test_list_view(self):
"""The list view contains a list of journal entries, which displays Title and Date for Entry."""
journal_entry_data_1 = {
'title':
'testing 1',
'date':
datetime.datetime.now().strftime('%Y-%m-%d'),
'time_spent':
'4',
'what_i_learned':
'how to test flask views',
'resources_to_remember':
'teamtreehouse.com, stackoverflow.com, flask.pocoo.org'
}
journal_entry_data_2 = {
'title':
'testing 123',
'date':
datetime.datetime.now().strftime('%Y-%m-%d'),
'time_spent':
'8',
'what_i_learned':
'how to test flask views',
'resources_to_remember':
'teamtreehouse.com, stackoverflow.com, flask.pocoo.org'
}
with test_database(TEST_DB, (User, JournalEntry)):
UserModelTestCase.create_users(1)
user = User.select().get()
journal_entry_data_1['user'] = user
journal_entry_data_2['user'] = user
JournalEntry.create(**journal_entry_data_1)
JournalEntry.create(**journal_entry_data_2)
self.app.post('/login', data=USER_DATA)
rv = self.app.get('/entries')
self.assertNotIn('No Entries...', rv.get_data(as_text=True))
self.assertIn(journal_entry_data_1['title'],
rv.get_data(as_text=True))
self.assertIn(journal_entry_data_1['date'],
rv.get_data(as_text=True))
self.assertIn(journal_entry_data_2['title'],
rv.get_data(as_text=True))
self.assertIn(journal_entry_data_2['date'],
rv.get_data(as_text=True))
def test_is_winner(self):
with test_database(test_db, [Race, Candidate], create_tables=True):
data.load_races('data/tests/init_races.json')
data.load_candidates('data/tests/init_candidates.json')
race = Race.get(Race.race_id == '38529-OR')
candidate = race.candidates.get()
candidate.ap_winner = True
candidate.save()
self.assertFalse(race.is_called())
self.assertFalse(candidate.is_winner())
race.ap_called = True
race.npr_called = False
race.accept_ap_call = True
race.save()
# Hack so the race updates override the cached FK
candidate.race = race
self.assertTrue(race.is_called())
self.assertTrue(candidate.is_winner())
candidate.ap_winner = False
candidate.save()
self.assertTrue(race.is_called())
self.assertFalse(candidate.is_winner())
race.accept_ap_call = False
race.save()
self.assertFalse(race.is_called())
race.npr_called = True
race.save()
self.assertTrue(race.is_called())
self.assertFalse(candidate.is_winner())
candidate.npr_winner = True
self.assertTrue(candidate.is_winner())
def test_get_episodes_returns_highest_quality_first(self):
with test_database(database, (Show, Episode)):
show = self._get_new_dummy_show()
show.save()
episode_one = self._get_new_dummy_episode(show)
episode_one.save()
episode_two = self._get_new_dummy_episode(show)
episode_two.quality = 1080
episode_two.save()
episodedownloadtask = EpisodeDownloadTask()
episodes = episodedownloadtask._get_episodes()
# Second episode has highest quality and should be first
self.assertEqual(episodes[0].id, episode_two.id)
self.assertEqual(episodes[1].id, episode_one.id)
def test_handle(self, bot, setup_update, test_db, updater):
"""Test setup handler."""
with test_database(test_db, [User], fail_silently=True):
with db.transaction():
user, created = User.tg_get_or_create(
setup_update.message.from_user)
user.state = setup_update.states[0]
user.save()
coach = Setup(bot, test_db, setup_update.message.from_user,
updater.job_queue)
messages = coach.handle(setup_update)
user, created = User.tg_get_or_create(
setup_update.message.from_user)
assert len(messages) > 0
assert user.state == setup_update.states[1]
def test_misc_article_methods(self):
with test_database(db, (Users, Articles)):
user1 = Users.create_user(username="******", password="******")
article = Articles.create_article(title="test article",
body="test",
draft=True,
author=user1)
Articles.update_article(article, title="changed", body="changed")
self.assertEquals("changed", article.title)
self.assertEquals("changed", article.body)
Articles.publish_article(article)
self.assertFalse(article.draft)
Articles.delete_article(article)
self.assertEquals(0, Articles.get_count(True))
def test_checksum_peewee_model_exception_not_possible_with_peewee(self):
clean_test_db = APSWDatabase(':memory:')
with test_database(clean_test_db, [NoPrimaryKeyTable]):
self.assertTrue(NoPrimaryKeyTable.table_exists())
ObserverDBUtil.checksum_peewee_model(NoPrimaryKeyTable, logging)
"""
No exception. That's because:
"Because we have not specified a primary key, peewee will automatically add
an auto-incrementing integer primary key field named id."
(http://docs.peewee-orm.com/en/latest/peewee/models.html)
"""
peewee_default_primary_key_field_name = 'id'
primary_key_field = NoPrimaryKeyTable._meta.primary_key
self.assertIsNotNone(primary_key_field)
self.assertEqual(peewee_default_primary_key_field_name, primary_key_field.name)
def test_update_state(self):
"""Test return and update of unique index."""
with test_database(TEST_DB, (BaseModel, IngestState)):
test_object = IngestState.create(job_id=999,
state='ERROR',
task='unbundling',
task_percent=42.3)
self.assertEqual(test_object.job_id, 999)
IngestState.database_close()
update_state(999, 'WORKING', 'validating', 33.2)
record = read_state(999)
self.assertEqual(record.state, 'WORKING')
self.assertEqual(record.task, 'validating')
self.assertEqual(float(record.task_percent), 33.2)
record = read_state(None)
self.assertEqual(record.state, 'DATA_ACCESS_ERROR')
self.assertEqual(record.task, 'read_state')
self.assertEqual(record.task_percent, 0)
def base_test_hash(self, obj_hash):
"""
Base hash test.
create a new object out of the hash
save the object to the DB
pull the object out of the DB using the obj_id column
create a new hash from the new object
check all keys in the new hash from the obj_hash passed
"""
with test_database(SqliteDatabase(':memory:'), self.dependent_cls()):
obj = self.base_create_obj(self.obj_cls, obj_hash)
new_obj = self.obj_cls.get(
self.obj_id == getattr(obj, self.obj_id.db_column))
chk_obj_hash = new_obj.to_hash()
self.assertTrue('_id' in chk_obj_hash)
for key in obj_hash.keys():
self.assertEqual(chk_obj_hash[key], obj_hash[key])
def test_taco_creation(self):
with test_database(TEST_DB, (User, Taco)):
UserModelTestCase.create_users()
user = User.select().get()
Taco.create(
user=user,
protein='chicken',
shell='flour',
cheese=False,
extras='Gimme some guac.'
)
taco = Taco.select().get()
self.assertEqual(
Taco.select().count(),
1
)
self.assertEqual(taco.user, user)
def test_single_date_search(self, mock_input,
mock_display_results, mock_stdout):
with test_database(test_db, [Task]):
Task.create(
employee='Richard',
name='Xeroxing',
date=datetime.date(2017, 8, 18),
time='60',
notes='Richmeister at the copy machine'
)
work_db.date_find()
self.assertIn('Not a valid selection', mock_stdout.getvalue())
self.assertIn('Pick one of the following dates ' +
'to view entries from', mock_stdout.getvalue())
self.assertIn('1: 2017-08-18 (1 entry)', mock_stdout.getvalue())
self.assertIn('Please enter a valid number',
mock_stdout.getvalue())
self.assertTrue(mock_display_results.called)
def test_insert():
lockdown_context.role = None
lockdown_context.user = None
lockdown_context.group = None
rest_api = Role('rest_api')
rest_api.lockdown(BigWheel) \
.writeable_by(BigWheel.owner == ContextParam('user'))\
.validate(BigWheel.owner, BigWheel.owner == ContextParam('user')) \
.field_writeable_by(BigWheel.serial, BigWheel.owner == ContextParam('user'))
with test_database(test_db, [User, Group, BigWheel]):
u1 = User.create(username='******')
u2 = User.create(username='******')
g = Group.create(name='test')
# set the role/user before inserting
lockdown_context.role = rest_api
lockdown_context.user = u1.id
try:
bwheel = BigWheel()
bwheel.owner = u2
bwheel.group = g
bwheel.serial = '1'
assert False, 'should have failed'
except LockdownException:
pass
# insert should work fine since object validates
bwheel = BigWheel()
bwheel.owner = u1
bwheel.group = g
bwheel.serial = '1'
bwheel.save()
b = BigWheel.get()
assert b.modified is not None
assert b.created is not None
assert b.serial == '1'
assert b.owner == u1
assert b.group == g
def test_not_ready_cart(self):
"""Testing the cart interface get against not ready cart"""
def start_response(*args):
"""stub for start_response to do some checking"""
self.assertEqual(args[0], '202 Accepted')
self.assertEqual(args[1][0][0], 'Content-Type')
self.assertEqual(args[1][0][1], 'application/json')
env = {'PATH_INFO': '/123', 'QUERY_STRING': ''}
with test_database(self.sqlite_db, (Cart, File)):
sample_cart = Cart()
sample_cart.cart_uid = 123
sample_cart.bundle_path = mkdtemp()
sample_cart.save(force_insert=True)
self.sqlite_db.close()
cgen = CartGenerator()
data = cgen.get(env, start_response)
self.assertEqual(
loads(data)['message'], 'The cart is not ready for download')
def test_on_message_remove_topic(self):
with test_database(test_db, (Log, Topic), create_tables=True):
self.client.subscribed_topics = []
self.client.subscribe('/test/topic/test1')
self.client.subscribe('/test/topic/test2')
self.client.subscribe('/test/topic/test3')
Topic.create(name='/test/topic/test1')
Topic.create(name='/test/topic/test2')
Topic.create(name='/test/topic/test3')
self.payload['options'] = None
self.payload['topic'] = '/test/topic/test3'
self.payload['password'] = Settings.MANAGEMENT_PASSWORD
self.msg = msg(topic=Settings.ROOT_TOPIC + 'topic/remove',
payload=json.dumps(self.payload))
mqtt_controller = MqttController()
result = mqtt_controller.on_message(self.client, self.msg)
self.assertEqual(2, len(self.client.subscribed_topics))
self.assertEqual(2, Topic.select().count())
def test_db():
"""Peewee Test DB context.
Example:
def test_NAME(test_db):
u = models.User(email="*****@*****.**", name="TESTER TESTERON")
u.save()
asser modls.User.count() == 1
"""
_db = SqliteDatabase(":memory:")
with test_database(_db, (
Organisation,
User,
UserOrg,
)) as _test_db:
yield _test_db
return
def test_search_entry(self):
with test_database(test_db, (work_log.Entry, )):
self.create_entries()
with unittest.mock.patch('builtins.input',
side_effect=["n", "test name", "", "m"]):
assert work_log.search_entry().count() == 1
with unittest.mock.patch(
'builtins.input',
side_effect=["d", "2000-01-01", "2000-01-01", "", "m"]):
assert work_log.search_entry().count() == 1
with unittest.mock.patch('builtins.input',
side_effect=["t", 200, "", "m"]):
assert work_log.search_entry().count() == 1
with unittest.mock.patch('builtins.input',
side_effect=["s", "test", "", "m"]):
assert work_log.search_entry().count() == 1
def test_checksum_peewee_model(self):
expected_sha1 = "689327755da6658627c0f015c25796a5cdc98c0c"
with test_database(self.test_db, [Settings]):
# Use Settings as test data table. Seed with two rows.
self.assertTrue(ObserverDBUtil.db_save_setting('TestSettingParam1', '1234'))
self.assertTrue(ObserverDBUtil.db_save_setting('TestSettingParam2', '4321'))
actual_sha1 = ObserverDBUtil.checksum_peewee_model(Settings, logging)
self.assertEqual(expected_sha1, actual_sha1)
# Change a digit: SHA1 should change.
self.assertTrue(ObserverDBUtil.db_save_setting('TestSettingParam2', '4221'))
actual_sha1 = ObserverDBUtil.checksum_peewee_model(Settings, logging)
self.assertNotEquals(expected_sha1, actual_sha1)
# Restore the original digit: SHA1's should match.
self.assertTrue(ObserverDBUtil.db_save_setting('TestSettingParam2', '4321'))
actual_sha1 = ObserverDBUtil.checksum_peewee_model(Settings, logging)
self.assertEqual(expected_sha1, actual_sha1)
def test_upload_upate(self):
with test_database(
test_db,
[model.Attachment, model.AttachmentRevision, model.Page]):
self.app.post('/index/attach',
data={'file': (StringIO('FOOBAR'), 'foo.bar')})
self.app.post('/index/attach',
data={'file': (StringIO('BARFOO'), 'foo.bar')})
sha = hashlib.sha256()
sha.update('BARFOO')
emptySha = sha.hexdigest()
uploadedFile = os.path.join(
self._app.config['UPLOAD_PATH'],
model.Attachment.hashPath(emptySha, 'foo.bar'))
self.assertTrue(os.path.exists(uploadedFile))
resp = self.app.get('/index/file/foo.bar')
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.data, 'BARFOO')
def base_test_json(self, json_str):
"""
Base test json.
pass the json string to the objects from_json method
save the object to the DB
get the new object using column in obj_id
convert the object to json
"""
with test_database(SqliteDatabase(':memory:'), self.dependent_cls()):
self.assertEqual(type(json_str), str)
self.base_create_dep_objs()
obj = self.obj_cls()
obj.from_json(json_str)
obj.save(force_insert=True)
new_obj = self.obj_cls.get(
self.obj_id == getattr(obj, self.obj_id.db_column))
chk_obj_json = new_obj.to_json()
self.assertEqual(type(chk_obj_json), str)
def test_can_post_a_todo_and_get_it_back(self):
with test_database(self.db_fd, models=(models.User, models.Todo)):
user = models.User.create_user(
'test_user',
'*****@*****.**',
'password',
)
user.save()
path = self.root_url + '/todos'
auth_payload = '{0}:{1}'.format(self.user_data['username'],
self.user_data['password'])
headers = {
'Authorization':
'Basic {}'.format(
b64encode(bytes(auth_payload,
encoding='ascii')).decode('ascii')),
}
resp = self.app.post(
path,
headers=headers,
data={
'name': 'test the application',
},
)
returned_creating_user_data = json.loads(
resp.data.decode())['new_todo']['creating_user']
self.assertEqual(resp.status, '201 CREATED')
self.assertEqual(returned_creating_user_data, user.username)
resp = self.app.get(
path,
headers=headers,
)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
json.loads(resp.data.decode())['todos'][0]['name'],
'test the application',
)
resp = self.app.delete(
path + '/1',
headers=headers,
)
self.assertEqual(resp.status_code, 204)
def test_is_readable_writable_field():
lockdown_context.role = None
lockdown_context.user = None
lockdown_context.group = None
rest_api = Role('rest_api')
rest_api.lockdown(BaseModel)\
.field_writeable_by(BaseModel.created, NO_ONE)\
.field_writeable_by(BaseModel.modified, NO_ONE)
rest_api.lockdown(Bicycle) \
.field_readable_by(Bicycle.serial, Bicycle.group == ContextParam('group')) \
.field_writeable_by(Bicycle.serial, Bicycle.owner == ContextParam('user'))
with test_database(test_db, [User, Group, Bicycle]):
u = User.create(username='******')
g = Group.create(name='test')
b = Bicycle.create(owner=u, group=g)
lockdown_context.role = rest_api
assert b.is_field_readable(Bicycle.serial) is False
assert b.is_field_writeable(Bicycle.serial) is False
assert b.is_field_writeable(Bicycle.modified) is False
assert b.is_field_writeable(Bicycle.created) is False
lockdown_context.group = 10
lockdown_context.user = 10
assert b.is_field_readable(Bicycle.serial) is False
assert b.is_field_writeable(Bicycle.serial) is False
lockdown_context.group = g.id
assert b.is_field_readable(Bicycle.serial) is True
assert b.is_field_writeable(Bicycle.serial) is False
lockdown_context.user = u.id
assert b.is_field_readable(Bicycle.serial) is True
assert b.is_field_writeable(Bicycle.serial) is True
def test_combined_roles():
server_api = Role('server_api')
server_api.lockdown(Bicycle) \
.writeable_by((Bicycle.group == ContextParam('group')) &
(ContextParam('custom_role') == 'admin'))
rest_api = server_api.extend('rest_api')
rest_api.lockdown(BaseModel)\
.field_writeable_by(BaseModel.created, NO_ONE)\
.field_writeable_by(BaseModel.modified, NO_ONE)
with test_database(test_db, [Group, Bicycle]):
g1 = Group.create(name='test1')
g2 = Group.create(name='test2')
b = Bicycle.create(group=g1)
lockdown_context.role = rest_api
lockdown_context.group = g1.id
lockdown_context.custom_role = 'admin'
b.serial = '1'
# make sure the group rule was inherited from server_api
lockdown_context.group = g2.id
try:
b.serial = '1'
assert False, 'should have failed'
except:
pass
# set group to the correct group, but shouldn't be able to set created
# since this is still the rest_api role
lockdown_context.group = g1.id
try:
b.created = datetime.utcnow()
assert False, 'should have failed'
except:
pass
# server_api can set created
lockdown_context.role = server_api
b.created = datetime.utcnow()
def test_stage_bad_file_id(self):
"""test a error return from a file not ready to pull"""
with test_database(SqliteDatabase(':memory:'), (Cart, File)):
def fake_database_connect(cls):
"""dont error with connect"""
return cls
def fake_database_close(cls):
"""dont actually close"""
return cls
cart.cart_orm.CartBase.database_connect = MethodType(
fake_database_connect, cart.cart_orm.CartBase)
cart.cart_orm.CartBase.database_close = MethodType(
fake_database_close, cart.cart_orm.CartBase)
cart.cart_orm.CartBase.throw_error = False
file_id = 9999999
stage_file_task(file_id)
self.assertEqual(True, True)
def test_hash_list_with_keys(self):
"""Test method to check the results of available hash list."""
sample_key1 = {'_id': 127, 'key': 'proposal', 'encoding': 'UTF8'}
sample_key2 = {'_id': 128, 'key': 'proposal', 'encoding': 'UTF8'}
sample_key3 = {'_id': 130, 'key': 'proposal', 'encoding': 'UTF8'}
with test_database(SqliteDatabase(':memory:'), [Keys]):
self.base_create_obj(Keys, sample_key1)
self.base_create_obj(Keys, sample_key2)
self.base_create_obj(Keys, sample_key3)
third_obj = Keys()
hash_list, hash_dict = third_obj.available_hash_list()
self.assertTrue(len(hash_list) == 3)
# some sanity checking for the layout of the two objects
for hashed_key in hash_list:
self.assertTrue(hashed_key in hash_dict)
obj_key_meta = hash_dict[hashed_key]
self.assertTrue('index_hash' in obj_key_meta)
self.assertTrue('key_list' in obj_key_meta)
self.assertTrue('id' in obj_key_meta['key_list'])
self.assertTrue(hashed_key == obj_key_meta['index_hash'])
def test_locations_updated_in_database(self):
"""
Test that position numbers are re-assigned according to datetime sort order.
Updates tested are those written to test database.
"""
n_expected = len(self.expected_position_assignments)
with test_database(self.test_db, self.test_tables):
self._load_up_test_location_data()
fishing_locations = ObserverFishingLocations()
fishing_locations.load_fishing_locations(self.test_activity_num)
# ----
fishing_locations._update_location_positions()
# ----
sorted_locations = FishingLocations.select().where(
FishingLocations.fishing_activity == self.test_activity_num)
self.assertEqual(n_expected, len(sorted_locations))
for sloc in sorted_locations:
print("{0} {1} ({2:0>5})".format(sloc.position, sloc.location_date, sloc.fishing_location))
self.assertEqual(self.expected_position_assignments[sloc.fishing_location], sloc.position)
def test_cart_int_get_no_file_fd(self):
"""Testing the cart interface get method w/o file_wrapper"""
def start_response(*args):
"""stub for start_response to do some checking"""
self.assertEqual(args[0], '200 OK')
self.assertEqual(args[1][0][0], 'Content-Type')
self.assertEqual(args[1][0][1], 'application/octet-stream')
env = {'PATH_INFO': '/123', 'QUERY_STRING': ''}
with test_database(self.sqlite_db, (Cart, File)):
sample_cart = Cart()
sample_cart.cart_uid = 123
sample_cart.bundle_path = mkdtemp()
sample_cart.status = 'ready'
sample_cart.save(force_insert=True)
self.sqlite_db.close()
cgen = CartGenerator()
tarfile_read = cgen.get(env, start_response)
for buf in tarfile_read:
self.assertTrue(len(buf) > 0)
