def test_stop_iteration_of_continuous_feed_with_heartbeat(self):
"""
Test stopping the iteration, test a continuous feed, and test
heartbeat functionality.
"""
feed = Feed(self.client, feed='continuous', timeout=100)
changes = list()
for change in feed:
if not change:
if not self.new_dbs:
self.create_dbs(5)
else:
continue
else:
changes.append(change)
if len(changes) == 3:
feed.stop()
self.assertEqual(len(self.new_dbs), 5)
self.assertEqual(len(changes), 3)
self.assertDictEqual(
changes[0], {'db_name': self.new_dbs[0].database_name, 'type': 'created'})
self.assertDictEqual(
changes[1], {'db_name': self.new_dbs[1].database_name, 'type': 'created'})
self.assertDictEqual(
changes[2], {'db_name': self.new_dbs[2].database_name, 'type': 'created'})
def test_get_raw_feed_with_heartbeat(self):
"""
Test getting raw content back for a feed with a heartbeat
"""
feed = Feed(self.client,
raw_data=True,
feed='continuous',
since='now',
heartbeat=1000)
raw_content = list()
heartbeats = 0
for raw_line in feed:
if not raw_line:
self.assertEqual(len(raw_line), 0)
heartbeats += 1
if heartbeats < 4:
self.create_dbs(1)
else:
self.assertIsInstance(raw_line, BYTETYPE)
raw_content.append(raw_line)
if heartbeats >= 3 and len(raw_content) >= 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
self.assertTrue(
changes[0]['seq'] < changes[1]['seq'] < changes[2]['seq'])
self.assertIsNone(feed.last_seq)
def test_stop_iteration_of_continuous_feed_with_heartbeat(self):
"""
Test stopping the iteration, test a continuous feed, and test
heartbeat functionality.
"""
feed = Feed(self.client, feed='continuous', timeout=100)
changes = list()
for change in feed:
if not change:
if not self.new_dbs:
self.create_dbs(5)
else:
continue
else:
changes.append(change)
if len(changes) == 3:
feed.stop()
self.assertEqual(len(self.new_dbs), 5)
self.assertEqual(len(changes), 3)
self.assertDictEqual(changes[0], {
'db_name': self.new_dbs[0].database_name,
'type': 'created'
})
self.assertDictEqual(changes[1], {
'db_name': self.new_dbs[1].database_name,
'type': 'created'
})
self.assertDictEqual(changes[2], {
'db_name': self.new_dbs[2].database_name,
'type': 'created'
})
def test_get_feed_using_since_now(self):
"""
Test getting content back for a feed using since set to "now"
"""
self.populate_db_with_documents(3)
feed = Feed(self.db, feed='continuous', heartbeat=1000, since='now')
changes = list()
first_pass = True
beats = 0
for change in feed:
if first_pass and not change:
self.populate_db_with_documents(3, off_set=3)
first_pass = False
continue
elif change:
self.assertSetEqual(set(change.keys()),
set(['seq', 'changes', 'id']))
changes.append(change)
beats = 0
else:
beats += 1
if beats == 15 or len(changes) == 3:
feed.stop()
expected = set(['julia003', 'julia004', 'julia005'])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
def test_get_feed_with_heartbeat(self):
"""
Test getting content back for a feed with a heartbeat
"""
feed = Feed(self.client,
feed='continuous',
since='now',
heartbeat=1000)
changes = list()
heartbeats = 0
for change in feed:
if not change:
self.assertIsNone(change)
heartbeats += 1
if heartbeats < 4:
self.create_dbs(1)
else:
self.assertTrue(all(x in change for x in ('seq', 'type')))
if len(changes) < 3:
changes.append(change)
if heartbeats >= 3 and len(changes) == 3:
feed.stop()
self.assertTrue(
changes[0]['seq'] < changes[1]['seq'] < changes[2]['seq'])
self.assertIsNone(feed.last_seq)
def test_get_raw_content(self):
"""
Test getting raw feed content
"""
feed = Feed(self.client,
raw_data='True',
feed='continuous',
timeout=100)
raw_content = list()
for raw_line in feed:
self.assertIsInstance(raw_line, BYTETYPE)
if not raw_line:
self.create_dbs(3)
else:
raw_content.append(raw_line)
if len(raw_content) == 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
self.assertDictEqual(changes[0], {
'db_name': self.new_dbs[0].database_name,
'type': 'created'
})
self.assertDictEqual(changes[1], {
'db_name': self.new_dbs[1].database_name,
'type': 'created'
})
self.assertDictEqual(changes[2], {
'db_name': self.new_dbs[2].database_name,
'type': 'created'
})
def create_dbs(self):
self.db_names = [self.dbname() for x in range(2)]
self.new_dbs += [self.client.create_database(dbname) for dbname in self.db_names]
# Verify that all created databases are listed in _db_updates
all_dbs_exist = False
while not all_dbs_exist:
changes = list()
feed = Feed(self.client, timeout=1000)
for change in feed:
changes.append(change)
if len(changes) == 3:
all_dbs_exist = True
feed.stop()
def test_get_raw_content(self):
"""
Test getting raw feed content
"""
feed = Feed(self.client, raw_data=True, feed='continuous', timeout=100)
raw_content = list()
for raw_line in feed:
self.assertIsInstance(raw_line, BYTETYPE)
raw_content.append(raw_line)
if len(raw_content) == 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
self.assert_changes_in_db_updates_feed(changes)
def test_stop_iteration_of_continuous_feed_with_heartbeat(self):
"""
Test stopping the iteration, test a continuous feed, and test
heartbeat functionality.
"""
feed = Feed(self.client, feed='continuous', timeout=100)
changes = list()
for change in feed:
changes.append(change)
if len(changes) == 3:
feed.stop()
self.assert_changes_in_db_updates_feed(changes)
self.assertEqual(len(changes), 3)
def test_get_continuous_with_timeout(self):
"""
Test getting content back for a "continuous" feed with timeout set
and no heartbeat
"""
feed = Feed(self.client, feed='continuous', heartbeat=False, timeout=1000)
changes = list()
for change in feed:
self.assertIsNotNone(change)
changes.append(change)
if len(changes) == 3:
feed.stop()
self.assert_changes_in_db_updates_feed(changes)
self.assertEqual(len(changes), 3)
def test_stop_iteration_of_continuous_feed_using_since_now(self):
"""
Test stopping the iteration, test continuous feed functionality, test
using since='now' option.
"""
feed = Feed(self.client, feed='continuous', since='now')
count = 0
changes = list()
for change in feed:
self.assertTrue(all(x in change for x in ('seq', 'type')))
changes.append(change)
count += 1
if count == 2:
feed.stop()
self.assertEqual(len(changes), 2)
self.assertTrue(changes[0]['seq'] < changes[1]['seq'])
self.assertIsNone(feed.last_seq)
def test_stop_iteration(self):
"""
Test stopping the iteration
"""
self.populate_db_with_documents(10)
feed = Feed(self.db, feed='continuous')
count = 0
changes = list()
for change in feed:
changes.append(change)
count += 1
if count == 3:
feed.stop()
self.assertEqual(len(change), 3)
self.assertTrue(str(changes[0]['seq']).startswith('1'))
self.assertTrue(str(changes[1]['seq']).startswith('2'))
self.assertTrue(str(changes[2]['seq']).startswith('3'))
self.assertIsNone(feed.last_seq)
def test_stop_iteration(self):
"""
Test stopping the iteration
"""
self.populate_db_with_documents(10)
feed = Feed(self.db, feed='continuous')
count = 0
changes = list()
for change in feed:
changes.append(change)
count += 1
if count == 3:
feed.stop()
self.assertEqual(len(change), 3)
self.assertTrue(str(changes[0]['seq']).startswith('1'))
self.assertTrue(str(changes[1]['seq']).startswith('2'))
self.assertTrue(str(changes[2]['seq']).startswith('3'))
self.assertIsNone(feed.last_seq)
def test_stop_iteration_of_continuous_feed_using_since_now(self):
"""
Test stopping the iteration, test continuous feed functionality, test
using since='now' option.
"""
feed = Feed(self.client, feed='continuous', since='now')
count = 0
changes = list()
self.create_dbs(3)
for change in feed:
self.assertTrue(all(x in change for x in ('seq', 'type')))
changes.append(change)
count += 1
if count == 2:
feed.stop()
self.assertEqual(len(changes), 2)
self.assertTrue(changes[0]['seq'] < changes[1]['seq'])
self.assertIsNone(feed.last_seq)
def test_get_continuous_feed(self):
"""
Test getting content back for a "continuous" feed
"""
self.populate_db_with_documents()
feed = Feed(self.db, feed='continuous')
changes = list()
for change in feed:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
if len(changes) == 100:
feed.stop()
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
# Compare continuous with normal
normal = Feed(self.db)
self.assertSetEqual(
set([x['id'] for x in changes]), set([n['id'] for n in normal]))
def tearDown(self):
"""
Reset test attributes
"""
test_dbs_deleted = False
changes = list()
[db.delete() for db in self.new_dbs]
# Check the changes in the _db_updates feed to assert that the test databases are deleted
while not test_dbs_deleted:
feed = Feed(self.client, timeout=1000)
for change in feed:
if change['db_name'] in self.db_names and change['type'] == 'deleted':
changes.append(change)
if len(changes) == 2:
test_dbs_deleted = True
feed.stop()
self.delete_db_updates()
self.client.disconnect()
super(DbUpdatesTestsBase, self).tearDown()
def test_get_continuous_feed(self):
"""
Test getting content back for a "continuous" feed
"""
self.populate_db_with_documents()
feed = Feed(self.db, feed='continuous')
changes = list()
for change in feed:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
if len(changes) == 100:
feed.stop()
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
# Compare continuous with normal
normal = Feed(self.db)
self.assertSetEqual(
set([x['id'] for x in changes]), set([n['id'] for n in normal]))
def test_get_longpoll_feed_as_default(self):
"""
Test getting content back for a "longpoll" feed
"""
feed = Feed(self.client, timeout=1000)
changes = list()
if self.is_couchdb_1x_version():
for change in feed:
self.assertIsNone(change)
changes.append(change)
self.assertEqual(len(changes), 1)
self.assertIsNone(changes[0])
else:
for change in feed:
self.assertIsNotNone(change)
changes.append(change)
if len(changes) == 3:
feed.stop()
self.assert_changes_in_db_updates_feed(changes)
self.assertEqual(len(changes), 3)
def test_get_feed_with_heartbeat(self):
"""
Test getting content back for a feed with a heartbeat
"""
self.populate_db_with_documents()
feed = Feed(self.db, feed='continuous', heartbeat=10)
changes = list()
heartbeats = 0
for change in feed:
if not change:
self.assertIsNone(change)
heartbeats += 1
else:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
if heartbeats == 3:
feed.stop()
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
def test_get_feed_with_heartbeat(self):
"""
Test getting content back for a feed with a heartbeat
"""
self.populate_db_with_documents()
feed = Feed(self.db, feed='continuous', heartbeat=10)
changes = list()
heartbeats = 0
for change in feed:
if not change:
self.assertIsNone(change)
heartbeats += 1
else:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
if heartbeats == 3:
feed.stop()
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
def test_get_raw_feed_with_heartbeat(self):
"""
Test getting raw content back for a feed with a heartbeat
"""
self.populate_db_with_documents()
feed = Feed(self.db, raw_data=True, feed='continuous', heartbeat=10)
raw_content = list()
heartbeats = 0
for raw_line in feed:
if not raw_line:
self.assertEqual(len(raw_line), 0)
heartbeats += 1
else:
self.assertIsInstance(raw_line, BYTETYPE)
raw_content.append(raw_line)
if heartbeats == 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
def test_get_raw_feed_with_heartbeat(self):
"""
Test getting raw content back for a feed with a heartbeat
"""
self.populate_db_with_documents()
feed = Feed(self.db, raw_data=True, feed='continuous', heartbeat=10)
raw_content = list()
heartbeats = 0
for raw_line in feed:
if not raw_line:
self.assertEqual(len(raw_line), 0)
heartbeats += 1
else:
self.assertIsInstance(raw_line, BYTETYPE)
raw_content.append(raw_line)
if heartbeats == 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
expected = set(['julia{0:03d}'.format(i) for i in range(100)])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertIsNone(feed.last_seq)
def test_get_feed_with_heartbeat(self):
"""
Test getting content back for a feed with a heartbeat
"""
feed = Feed(self.client, feed='continuous', since='now', heartbeat=1000)
changes = list()
heartbeats = 0
for change in feed:
if not change:
self.assertIsNone(change)
heartbeats += 1
if heartbeats < 4:
self.create_dbs(1)
else:
self.assertTrue(all(x in change for x in ('seq', 'type')))
if len(changes) < 3:
changes.append(change)
if heartbeats >= 3 and len(changes) == 3:
feed.stop()
self.assertTrue(changes[0]['seq'] < changes[1]['seq'] < changes[2]['seq'])
self.assertIsNone(feed.last_seq)
def test_get_raw_content(self):
"""
Test getting raw feed content
"""
feed = Feed(self.client, raw_data='True', feed='continuous', timeout=100)
raw_content = list()
for raw_line in feed:
self.assertIsInstance(raw_line, BYTETYPE)
if not raw_line:
self.create_dbs(3)
else:
raw_content.append(raw_line)
if len(raw_content) == 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
self.assertDictEqual(
changes[0], {'db_name': self.new_dbs[0].database_name, 'type': 'created'})
self.assertDictEqual(
changes[1], {'db_name': self.new_dbs[1].database_name, 'type': 'created'})
self.assertDictEqual(
changes[2], {'db_name': self.new_dbs[2].database_name, 'type': 'created'})
def test_get_feed_using_timeout(self):
"""
Test getting content back for a feed using timeout. Since we do not
have control over updates happening within the account as we do within a
database, this test is stopped after 15 changes are received which
should theoretically not happen but we still need a way to break out of
the test if necessary.
"""
feed = Feed(self.client, feed='continuous', since='now', timeout=1000)
count = 0
self.create_dbs(1)
for change in feed:
self.assertTrue(all(x in change for x in ('seq', 'type')))
count += 1
if count == 15:
feed.stop()
# The test is considered a success if the last_seq value exists on the
# feed object. One would not exist if the feed was stopped via .stop().
# If failure occurs it does not necessarily mean that the InfiniteFeed
# is not functioning as expected, it might also mean that we reached the
# changes limit threshold of 15 before a timeout could happen.
self.assertIsNotNone(feed.last_seq)
def test_get_raw_feed_with_heartbeat(self):
"""
Test getting raw content back for a feed with a heartbeat
"""
feed = Feed(self.client, raw_data=True, feed='continuous', since='now',
heartbeat=1000)
raw_content = list()
heartbeats = 0
for raw_line in feed:
if not raw_line:
self.assertEqual(len(raw_line), 0)
heartbeats += 1
if heartbeats < 4:
self.create_dbs(1)
else:
self.assertIsInstance(raw_line, BYTETYPE)
raw_content.append(raw_line)
if heartbeats >= 3 and len(raw_content) >= 3:
feed.stop()
changes = [json.loads(unicode_(x)) for x in raw_content]
self.assertTrue(changes[0]['seq'] < changes[1]['seq'] < changes[2]['seq'])
self.assertIsNone(feed.last_seq)
def test_get_feed_using_timeout(self):
"""
Test getting content back for a feed using timeout. Since we do not
have control over updates happening within the account as we do within a
database, this test is stopped after 15 changes are received which
should theoretically not happen but we still need a way to break out of
the test if necessary.
"""
feed = Feed(self.client, feed='continuous', since='now', timeout=1000)
count = 0
self.create_dbs(1)
for change in feed:
self.assertTrue(all(x in change for x in ('seq', 'type')))
count += 1
if count == 15:
feed.stop()
# The test is considered a success if the last_seq value exists on the
# feed object. One would not exist if the feed was stopped via .stop().
# If failure occurs it does not necessarily mean that the InfiniteFeed
# is not functioning as expected, it might also mean that we reached the
# changes limit threshold of 15 before a timeout could happen.
self.assertIsNotNone(feed.last_seq)
def test_get_feed_using_since_now(self):
"""
Test getting content back for a feed using since set to "now"
"""
self.populate_db_with_documents(3)
feed = Feed(self.db, feed='continuous', heartbeat=1000, since='now')
changes = list()
first_pass = True
beats = 0
for change in feed:
if first_pass and not change:
self.populate_db_with_documents(3, off_set=3)
first_pass = False
continue
elif change:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
beats = 0
else:
beats += 1
if beats == 15 or len(changes) == 3:
feed.stop()
expected = set(['julia003', 'julia004', 'julia005'])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
