def rest_scan(sync_gateway, db, online, num_docs, user_name, channels):
# Missing ADMIN
# TODO: GET /{db}/_session/{session-id}
# TODO: POST /{db}/_session
# TODO: DELETE /{db}/_session/{session-id}
# TODO: DELETE /{db}/_user/{name}/_session/{session-id}
# TODO: DELETE /{db}/_user/{name}/_session
# TODO: DELETE /{db}/_user/{name}
# TODO: POST /{db}/_role/
# TODO: DELETE /{db}/_role/{name}
# Missing REST
# TODO: POST /{db}/_all_docs
# TODO: DELETE /{db}/{doc}
# TODO: PUT /{db}/{doc}/{attachment}
# TODO: GET /{db}/{doc}/{attachment}
# Missing Local Document
# TODO: DELETE /{db}/{local-doc-id}
# Missing Authentication
# TODO: POST /{db}/_facebook_token
admin = Admin(sync_gateway=sync_gateway)
error_responses = list()
# PUT /{db}/_role/{name}
try:
admin.create_role(db=db, name="radio_stations", channels=["HWOD", "KDWB"])
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_role
try:
roles = admin.get_roles(db=db)
log_info(roles)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_role/{name}
try:
role = admin.get_role(db=db, name="radio_stations")
log_info(role)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# PUT /{db}/_user/{name}
try:
user = admin.register_user(target=sync_gateway, db=db, name=user_name, password="******", channels=channels)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_user
try:
users_info = admin.get_users_info(db=db)
log_info(users_info)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_user/{name}
try:
user_info = admin.get_user_info(db=db, name=user_name)
log_info(user_info)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}
try:
db_info = admin.get_db_info(db=db)
if not online:
assert db_info["state"] == "Offline"
else:
assert db_info["state"] == "Online"
log_info(db_info)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# Create dummy user to hit endpoint if offline, user creation above will fail
if not online:
user = User(target=sync_gateway, db=db, name=user_name, password="******", channels=channels)
# PUT /{db}/{name}
add_docs_errors = user.add_docs(num_docs=num_docs)
error_responses.extend(add_docs_errors)
# POST /{db}/_bulk_docs
bulk_doc_errors = user.add_docs(num_docs=num_docs, bulk=True)
error_responses.extend(bulk_doc_errors)
# POST /{db}/
for i in range(num_docs):
try:
user.add_doc()
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/{name}
# PUT /{db}/{name}
if online:
update_docs_errors = user.update_docs(num_revs_per_doc=1)
error_responses.extend(update_docs_errors)
else:
try:
# Try to hit the GET enpoint for "test-id"
user.update_doc("test-id")
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# PUT /{db}/{local-doc-id}
local_doc_id = uuid.uuid4()
try:
doc = user.add_doc("_local/{}".format(local_doc_id), content={"message": "I should not be replicated"})
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/{local-doc-id}
try:
doc = user.get_doc("_local/{}".format(local_doc_id))
assert doc["content"]["message"] == "I should not be replicated"
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_all_docs
try:
all_docs_result = user.get_all_docs()
# num_docs /{db}/{doc} PUT + num_docs /{db}/_bulk_docs + num_docs POST /{db}/
assert len(all_docs_result["rows"]) == num_docs * 3
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# POST /{db}/_bulk_get
try:
doc_ids = list(user.cache.keys())
first_ten_ids = doc_ids[:10]
first_ten = user.get_docs(first_ten_ids)
assert len(first_ten) == 10
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# wait for changes
time.sleep(2)
# GET /{db}/_changes
try:
user.get_changes()
# If successful, verify the _changes feed
verify_changes(user, expected_num_docs=num_docs * 3, expected_num_revisions=1, expected_docs=user.cache)
except HTTPError as e:
log_info((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
return error_responses
def test_roles_sanity(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'roles_sanity'")
log_info("cluster_conf: {}".format(cluster_conf))
log_info("sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
radio_stations = ["KMOW", "HWOD", "KDWB"]
tv_stations = ["ABC", "CBS", "NBC"]
number_of_djs = 10
number_of_vjs = 10
number_of_docs_per_pusher = 500
admin = Admin(cluster.sync_gateways[0])
admin.create_role("db", name="radio_stations", channels=radio_stations)
admin.create_role("db", name="tv_stations", channels=tv_stations)
djs = admin.register_bulk_users(target=cluster.sync_gateways[0],
db="db",
name_prefix="dj",
number=number_of_djs,
password="******",
roles=["radio_stations"])
vjs = admin.register_bulk_users(target=cluster.sync_gateways[0],
db="db",
name_prefix="vj",
number=number_of_vjs,
password="******",
roles=["tv_stations"])
mogul = admin.register_user(target=cluster.sync_gateways[0],
db="db",
name="mogul",
password="******",
roles=["tv_stations", "radio_stations"])
radio_doc_caches = []
for radio_station in radio_stations:
doc_pusher = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="{}_doc_pusher".format(radio_station),
password="******",
channels=[radio_station])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
radio_doc_caches.append(doc_pusher.cache)
radio_docs = {k: v for cache in radio_doc_caches for k, v in cache.items()}
tv_doc_caches = []
for tv_station in tv_stations:
doc_pusher = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="{}_doc_pusher".format(tv_station),
password="******",
channels=[tv_station])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
tv_doc_caches.append(doc_pusher.cache)
tv_docs = {k: v for cache in tv_doc_caches for k, v in cache.items()}
# Verify djs get docs for all the channels associated with the radio_stations role
expected_num_radio_docs = len(radio_stations) * number_of_docs_per_pusher
verify_changes(djs,
expected_num_docs=expected_num_radio_docs,
expected_num_revisions=0,
expected_docs=radio_docs)
# Verify vjs get docs for all the channels associated with the tv_stations role
expected_num_tv_docs = len(tv_stations) * number_of_docs_per_pusher
verify_changes(vjs,
expected_num_docs=expected_num_tv_docs,
expected_num_revisions=0,
expected_docs=tv_docs)
# Verify mogul gets docs for all the channels associated with the radio_stations + tv_stations roles
all_docs_caches = list(radio_doc_caches)
all_docs_caches.extend(tv_doc_caches)
all_docs = {k: v for cache in all_docs_caches for k, v in cache.items()}
verify_changes(mogul,
expected_num_docs=expected_num_radio_docs +
expected_num_tv_docs,
expected_num_revisions=0,
expected_docs=all_docs)
def test_roles_sanity(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'roles_sanity'")
log_info("cluster_conf: {}".format(cluster_conf))
log_info("sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
radio_stations = ["KMOW", "HWOD", "KDWB"]
tv_stations = ["ABC", "CBS", "NBC"]
number_of_djs = 10
number_of_vjs = 10
number_of_docs_per_pusher = 500
admin = Admin(cluster.sync_gateways[0])
admin.create_role("db", name="radio_stations", channels=radio_stations)
admin.create_role("db", name="tv_stations", channels=tv_stations)
djs = admin.register_bulk_users(target=cluster.sync_gateways[0], db="db", name_prefix="dj", number=number_of_djs, password="******", roles=["radio_stations"])
vjs = admin.register_bulk_users(target=cluster.sync_gateways[0], db="db", name_prefix="vj", number=number_of_vjs, password="******", roles=["tv_stations"])
mogul = admin.register_user(target=cluster.sync_gateways[0], db="db", name="mogul", password="******", roles=["tv_stations", "radio_stations"])
radio_doc_caches = []
for radio_station in radio_stations:
doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="{}_doc_pusher".format(radio_station), password="******", channels=[radio_station])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
radio_doc_caches.append(doc_pusher.cache)
radio_docs = {k: v for cache in radio_doc_caches for k, v in cache.items()}
tv_doc_caches = []
for tv_station in tv_stations:
doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="{}_doc_pusher".format(tv_station), password="******", channels=[tv_station])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
tv_doc_caches.append(doc_pusher.cache)
tv_docs = {k: v for cache in tv_doc_caches for k, v in cache.items()}
# Verify djs get docs for all the channels associated with the radio_stations role
expected_num_radio_docs = len(radio_stations) * number_of_docs_per_pusher
verify_changes(djs, expected_num_docs=expected_num_radio_docs, expected_num_revisions=0, expected_docs=radio_docs)
# Verify vjs get docs for all the channels associated with the tv_stations role
expected_num_tv_docs = len(tv_stations) * number_of_docs_per_pusher
verify_changes(vjs, expected_num_docs=expected_num_tv_docs, expected_num_revisions=0, expected_docs=tv_docs)
# Verify mogul gets docs for all the channels associated with the radio_stations + tv_stations roles
all_docs_caches = list(radio_doc_caches)
all_docs_caches.extend(tv_doc_caches)
all_docs = {k: v for cache in all_docs_caches for k, v in cache.items()}
verify_changes(mogul, expected_num_docs=expected_num_radio_docs + expected_num_tv_docs, expected_num_revisions=0, expected_docs=all_docs)
def test_sync_require_roles(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'sync_require_roles'")
log_info("Using cluster_conf: {}".format(cluster_conf))
log_info("Using sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
radio_stations = ["KMOW", "HWOD", "KDWB"]
tv_stations = ["ABC", "CBS", "NBC"]
number_of_djs = 10
number_of_vjs = 10
number_of_docs_per_pusher = 100
admin = Admin(cluster.sync_gateways[0])
admin.create_role("db", name="radio_stations", channels=radio_stations)
admin.create_role("db", name="tv_stations", channels=tv_stations)
djs = admin.register_bulk_users(target=cluster.sync_gateways[0],
db="db",
name_prefix="dj",
number=number_of_djs,
password="******",
roles=["radio_stations"])
vjs = admin.register_bulk_users(target=cluster.sync_gateways[0],
db="db",
name_prefix="vj",
number=number_of_vjs,
password="******",
roles=["tv_stations"])
mogul = admin.register_user(target=cluster.sync_gateways[0],
db="db",
name="mogul",
password="******",
roles=["tv_stations", "radio_stations"])
radio_doc_caches = []
for radio_station in radio_stations:
doc_pusher = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="{}_doc_pusher".format(radio_station),
password="******",
channels=[radio_station],
roles=["radio_stations"])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
radio_doc_caches.append(doc_pusher.cache)
expected_num_radio_docs = len(radio_stations) * number_of_docs_per_pusher
# All docs that have been pushed with the "radio_stations" role
all_radio_docs = {
k: v
for cache in radio_doc_caches for k, v in cache.items()
}
tv_doc_caches = []
for tv_station in tv_stations:
doc_pusher = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="{}_doc_pusher".format(tv_station),
password="******",
channels=[tv_station],
roles=["tv_stations"])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
tv_doc_caches.append(doc_pusher.cache)
expected_num_tv_docs = len(tv_stations) * number_of_docs_per_pusher
# All docs that have been pushed with the "tv_stations" role
all_tv_docs = {k: v for cache in tv_doc_caches for k, v in cache.items()}
# Read only users
radio_channels_no_roles_user = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="bad_radio_user",
password="******",
channels=radio_stations)
tv_channel_no_roles_user = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="bad_tv_user",
password="******",
channels=tv_stations)
# Should not be allowed
radio_channels_no_roles_user.add_docs(13, name_prefix="bad_doc")
tv_channel_no_roles_user.add_docs(26, name_prefix="bad_doc")
read_only_user_caches = [
radio_channels_no_roles_user.cache, tv_channel_no_roles_user.cache
]
read_only_user_docs = {
k: v
for cache in read_only_user_caches for k, v in cache.items()
}
# Dictionary should be empty if they were blocked from pushing docs
assert len(read_only_user_docs.items()) == 0
# It seems be non deterministic but sometimes when issuing the changes call return, some of the documents are returned but not all.
# There is currently no retry loop in verify_changes and I'm guessing that the bulk_docs requests are still processing.
time.sleep(5)
# Should recieve docs from radio_channels
verify_changes(radio_channels_no_roles_user,
expected_num_docs=expected_num_radio_docs,
expected_num_revisions=0,
expected_docs=all_radio_docs)
# Should recieve docs from tv_channels
verify_changes(tv_channel_no_roles_user,
expected_num_docs=expected_num_tv_docs,
expected_num_revisions=0,
expected_docs=all_tv_docs)
# verify all djs with the 'radio_stations' role get the docs with radio station channels
verify_changes(djs,
expected_num_docs=expected_num_radio_docs,
expected_num_revisions=0,
expected_docs=all_radio_docs)
# verify all djs with the 'radio_stations' role get the docs with radio station channels
verify_changes(vjs,
expected_num_docs=expected_num_tv_docs,
expected_num_revisions=0,
expected_docs=all_tv_docs)
# Verify mogul gets docs for all the channels associated with the radio_stations + tv_stations roles
all_doc_caches = list(radio_doc_caches)
all_doc_caches.extend(tv_doc_caches)
all_docs = {k: v for cache in all_doc_caches for k, v in cache.items()}
for k, v in all_docs.items():
assert not k.startswith("bad_doc")
verify_changes(mogul,
expected_num_docs=expected_num_radio_docs +
expected_num_tv_docs,
expected_num_revisions=0,
expected_docs=all_docs)
def test_sync_role_sanity(params_from_base_test_setup, sg_conf_name):
num_docs_per_channel = 100
tv_channels = ["ABC", "NBC", "CBS"]
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'sync_role_sanity'")
log_info("Using cluster_conf: {}".format(cluster_conf))
log_info("Using sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
admin = Admin(cluster.sync_gateways[0])
admin.create_role(db="db", name="tv_stations", channels=tv_channels)
seth = admin.register_user(target=cluster.sync_gateways[0],
db="db",
name="seth",
password="******")
doc_pushers = []
doc_pusher_caches = []
# Push some ABC docs
for tv_channel in tv_channels:
doc_pusher = admin.register_user(
target=cluster.sync_gateways[0],
db="db",
name="{}_doc_pusher".format(tv_channel),
password="******",
channels=[tv_channel])
doc_pusher.add_docs(num_docs_per_channel, bulk=True)
doc_pushers.append(doc_pusher)
doc_pusher_caches.append(doc_pusher.cache)
# Before role access grant
verify_changes(seth,
expected_num_docs=0,
expected_num_revisions=0,
expected_docs={})
# Create access doc pusher and grant access Seth to ABC channel
access_doc_pusher = admin.register_user(target=cluster.sync_gateways[0],
db="db",
name="access_doc_pusher",
password="******",
channels=["access"])
access_doc_pusher.add_doc(doc_id="access_doc",
content={"grant_access": "true"})
# Allow docs to backfill
time.sleep(5)
all_tv_docs = {
k: v
for cache in doc_pusher_caches for k, v in cache.items()
}
verify_changes(seth,
expected_num_docs=num_docs_per_channel * len(tv_channels),
expected_num_revisions=0,
expected_docs=all_tv_docs)
# Remove seth from tv_stations role
access_doc_pusher.update_doc(doc_id="access_doc",
content={"grant_access": "false"})
# Allow docs to backfill
time.sleep(5)
# Verify seth sees no tv_stations channel docs
verify_changes(seth,
expected_num_docs=0,
expected_num_revisions=0,
expected_docs={})
# Push more ABC docs
for doc_pusher in doc_pushers:
doc_pusher.add_docs(num_docs_per_channel, bulk=True)
# Allow docs to backfill
time.sleep(5)
# Verify seth sees no tv_stations channel docs
verify_changes(seth,
expected_num_docs=0,
expected_num_revisions=0,
expected_docs={})
def test_sync_require_roles(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'sync_require_roles'")
log_info("Using cluster_conf: {}".format(cluster_conf))
log_info("Using sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
radio_stations = ["KMOW", "HWOD", "KDWB"]
tv_stations = ["ABC", "CBS", "NBC"]
number_of_djs = 10
number_of_vjs = 10
number_of_docs_per_pusher = 100
admin = Admin(cluster.sync_gateways[0])
admin.create_role("db", name="radio_stations", channels=radio_stations)
admin.create_role("db", name="tv_stations", channels=tv_stations)
djs = admin.register_bulk_users(target=cluster.sync_gateways[0], db="db", name_prefix="dj", number=number_of_djs, password="******", roles=["radio_stations"])
vjs = admin.register_bulk_users(target=cluster.sync_gateways[0], db="db", name_prefix="vj", number=number_of_vjs, password="******", roles=["tv_stations"])
mogul = admin.register_user(target=cluster.sync_gateways[0], db="db", name="mogul", password="******", roles=["tv_stations", "radio_stations"])
radio_doc_caches = []
for radio_station in radio_stations:
doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="{}_doc_pusher".format(radio_station), password="******", channels=[radio_station], roles=["radio_stations"])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
radio_doc_caches.append(doc_pusher.cache)
expected_num_radio_docs = len(radio_stations) * number_of_docs_per_pusher
# All docs that have been pushed with the "radio_stations" role
all_radio_docs = {k: v for cache in radio_doc_caches for k, v in cache.items()}
tv_doc_caches = []
for tv_station in tv_stations:
doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="{}_doc_pusher".format(tv_station), password="******", channels=[tv_station], roles=["tv_stations"])
doc_pusher.add_docs(number_of_docs_per_pusher, bulk=True)
tv_doc_caches.append(doc_pusher.cache)
expected_num_tv_docs = len(tv_stations) * number_of_docs_per_pusher
# All docs that have been pushed with the "tv_stations" role
all_tv_docs = {k: v for cache in tv_doc_caches for k, v in cache.items()}
# Read only users
radio_channels_no_roles_user = admin.register_user(target=cluster.sync_gateways[0], db="db", name="bad_radio_user", password="******", channels=radio_stations)
tv_channel_no_roles_user = admin.register_user(target=cluster.sync_gateways[0], db="db", name="bad_tv_user", password="******", channels=tv_stations)
# Should not be allowed
radio_channels_no_roles_user.add_docs(13, name_prefix="bad_doc")
tv_channel_no_roles_user.add_docs(26, name_prefix="bad_doc")
read_only_user_caches = [radio_channels_no_roles_user.cache, tv_channel_no_roles_user.cache]
read_only_user_docs = {k: v for cache in read_only_user_caches for k, v in cache.items()}
# Dictionary should be empty if they were blocked from pushing docs
assert len(read_only_user_docs.items()) == 0
# It seems be non deterministic but sometimes when issuing the changes call return, some of the documents are returned but not all.
# There is currently no retry loop in verify_changes and I'm guessing that the bulk_docs requests are still processing.
time.sleep(5)
# Should recieve docs from radio_channels
verify_changes(radio_channels_no_roles_user, expected_num_docs=expected_num_radio_docs, expected_num_revisions=0, expected_docs=all_radio_docs)
# Should recieve docs from tv_channels
verify_changes(tv_channel_no_roles_user, expected_num_docs=expected_num_tv_docs, expected_num_revisions=0, expected_docs=all_tv_docs)
# verify all djs with the 'radio_stations' role get the docs with radio station channels
verify_changes(djs, expected_num_docs=expected_num_radio_docs, expected_num_revisions=0, expected_docs=all_radio_docs)
# verify all djs with the 'radio_stations' role get the docs with radio station channels
verify_changes(vjs, expected_num_docs=expected_num_tv_docs, expected_num_revisions=0, expected_docs=all_tv_docs)
# Verify mogul gets docs for all the channels associated with the radio_stations + tv_stations roles
all_doc_caches = list(radio_doc_caches)
all_doc_caches.extend(tv_doc_caches)
all_docs = {k: v for cache in all_doc_caches for k, v in cache.items()}
for k, v in all_docs.items():
assert not k.startswith("bad_doc")
verify_changes(mogul, expected_num_docs=expected_num_radio_docs + expected_num_tv_docs, expected_num_revisions=0, expected_docs=all_docs)
def test_sync_role_sanity(params_from_base_test_setup, sg_conf_name):
num_docs_per_channel = 100
tv_channels = ["ABC", "NBC", "CBS"]
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
log_info("Running 'sync_role_sanity'")
log_info("Using cluster_conf: {}".format(cluster_conf))
log_info("Using sg_conf: {}".format(sg_conf))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
admin = Admin(cluster.sync_gateways[0])
admin.create_role(db="db", name="tv_stations", channels=tv_channels)
seth = admin.register_user(target=cluster.sync_gateways[0], db="db", name="seth", password="******")
doc_pushers = []
doc_pusher_caches = []
# Push some ABC docs
for tv_channel in tv_channels:
doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="{}_doc_pusher".format(tv_channel), password="******", channels=[tv_channel])
doc_pusher.add_docs(num_docs_per_channel, bulk=True)
doc_pushers.append(doc_pusher)
doc_pusher_caches.append(doc_pusher.cache)
# Before role access grant
verify_changes(seth, expected_num_docs=0, expected_num_revisions=0, expected_docs={})
# Create access doc pusher and grant access Seth to ABC channel
access_doc_pusher = admin.register_user(target=cluster.sync_gateways[0], db="db", name="access_doc_pusher", password="******", channels=["access"])
access_doc_pusher.add_doc(doc_id="access_doc", content={"grant_access": "true"})
# Allow docs to backfill
time.sleep(5)
all_tv_docs = {k: v for cache in doc_pusher_caches for k, v in cache.items()}
verify_changes(seth, expected_num_docs=num_docs_per_channel * len(tv_channels), expected_num_revisions=0, expected_docs=all_tv_docs)
# Remove seth from tv_stations role
access_doc_pusher.update_doc(doc_id="access_doc", content={"grant_access": "false"})
# Allow docs to backfill
time.sleep(5)
# Verify seth sees no tv_stations channel docs
verify_changes(seth, expected_num_docs=0, expected_num_revisions=0, expected_docs={})
# Push more ABC docs
for doc_pusher in doc_pushers:
doc_pusher.add_docs(num_docs_per_channel, bulk=True)
# Allow docs to backfill
time.sleep(5)
# Verify seth sees no tv_stations channel docs
verify_changes(seth, expected_num_docs=0, expected_num_revisions=0, expected_docs={})
