def test_update(app, field_ids, expected_field_ids): type_id = 2 with app.app_context(): count = TypeFieldAssociation.query.count() model = ProductType.query.filter_by(type_id=type_id).one() expected_len_change = len(model.fields) - len(expected_field_ids) with app.app_context(): model = ops.update_product_type( type_id=type_id, name="compass", field_ids=field_ids ) ops.commit() assert model.name == "compass" with app.app_context(): model = ProductType.query.filter_by(type_id=type_id).one() assert model.name == "compass" actual_field_ids = [f.field.field_id for f in model.fields] assert actual_field_ids == expected_field_ids # assert unused TypeFieldAssociation is deleted actual_len_change = count - TypeFieldAssociation.query.count() assert expected_len_change == actual_len_change
def test_update_error(app, field_ids): type_id = 2 with app.app_context(): count = TypeFieldAssociation.query.count() with app.app_context(): with pytest.raises(exc.NoResultFound): model = ops.update_product_type( type_id=type_id, name="compass", field_ids=field_ids, ) ops.commit() # commit() won't be called because of the exception with app.app_context(): model = ProductType.query.filter_by(type_id=type_id).one() assert model.name == "beam" actual_field_ids = [f.field.field_id for f in model.fields] expected_field_ids = [1, 2, 3, 7, 9] assert actual_field_ids == expected_field_ids assert TypeFieldAssociation.query.count() == count
def app(app_users): y = app_users with y.app_context(): ops.create_log(id_=1, level="DEBUG", message="A debug message!") ops.create_log(id_=2, level="ERROR", message="An error message!") ops.commit() yield y
def _test_convert( app, updating_git_hub_user_id=None, ): product_id = 1 type_id = 2 kwargs = {"product_id": product_id, "type_id": type_id} if updating_git_hub_user_id: kwargs["updating_git_hub_user_id"] = updating_git_hub_user_id attr_names = [ a.attribute_class.backref_column for a in FieldType.__members__.values() ] # e.g., 'attributes_unicode_text', 'attributes_boolean' with app.app_context(): model = Product.query.filter_by(product_id=product_id).one() assert not model.type_.type_id == type_id value_dict = { e.field_id: e.value for attr in attr_names for e in getattr(model, attr) } product_type = ProductType.query.filter_by(type_id=type_id).one() expected_field_values = [(assoc.field_id, value_dict.get(assoc.field_id)) for assoc in product_type.fields] with app.app_context(): model = ops.convert_product_type(**kwargs) assert model ops.commit() with app.app_context(): model = Product.query.filter_by(product_id=product_id).one() assert model.type_.type_id == type_id if updating_git_hub_user_id: updating_git_hub_user = GitHubUser.query.filter_by( user_id=updating_git_hub_user_id).one() assert model.updating_git_hub_user == updating_git_hub_user else: assert model.updating_git_hub_user is None expected_ids = [(a.iid, a.field_id) for a in model.type_.fields] attrs = [e for attr in attr_names for e in getattr(model, attr)] for attr in attrs: assert attr.type_field_association.type_ == model.type_ actual_ids = [(e.type_field_association.iid, e.field_id) for e in attrs] assert set(expected_ids) == set(actual_ids) actual_field_values = [(a.field_id, a.value) for a in attrs] assert set(expected_field_values) == set(actual_field_values)
def test_create_error_neither(app): type_ = {"name": "doctor"} with app.app_context(): count = ProductRelationType.query.count() with pytest.raises(ValueError): ops.create_product_relation_type(type_) ops.commit() with app.app_context(): assert ProductRelationType.query.count() == count
def test_create_error_both(app): type_ = {"name": "doctor"} reverse = {"name": "patient"} with app.app_context(): count = ProductRelationType.query.count() with pytest.raises(ValueError): ops.create_product_relation_type(type_, reverse, self_reverse=True) ops.commit() with app.app_context(): assert ProductRelationType.query.count() == count
def test_create(app): with app.app_context(): count = ProductFilePath.query.count() model = ops.create_product_file_path(path="/new/path") assert model.path == "/new/path" ops.commit() path_id = model.path_id assert path_id with app.app_context(): assert ProductFilePath.query.count() == (count + 1) model = ProductFilePath.query.filter_by(path_id=path_id).one() assert model.path == "/new/path"
def test_create(app): with app.app_context(): count = Log.query.count() model = ops.create_log(level="ERROR", message="An exception occurred") assert model.message == "An exception occurred" ops.commit() id_ = model.id_ assert id_ with app.app_context(): assert Log.query.count() == (count + 1) model = Log.query.filter_by(id_=id_).one() assert model.message == "An exception occurred"
def test_create(app): with app.app_context(): count = ProductRelation.query.count() model = ops.create_product_relation( type_id=1, self_product_id=1, other_product_id=4 ) ops.commit() relation_id = model.relation_id assert relation_id with app.app_context(): assert ProductRelation.query.count() == (count + 2) model = ProductRelation.query.filter_by(relation_id=relation_id).one() assert model.reverse
def test_update(app): with app.app_context(): model = Field.query.filter_by(name="number").one() field_id = model.field_id with app.app_context(): model = ops.update_field(field_id=field_id, name="number_renamed") ops.commit() with app.app_context(): model = Field.query.filter_by(field_id=field_id).one() assert model.name == "number_renamed" assert model.field_id == field_id
def test_delete(app): with app.app_context(): model = ops.create_log(level="ERROR", message="To be deleted") ops.commit() id_ = model.id_ with app.app_context(): count = Log.query.count() ops.delete_log(id_=id_) ops.commit() with app.app_context(): assert Log.query.count() == (count - 1) model = Log.query.filter_by(id_=id_).one_or_none() assert model is None
def test_create_self_reverse(app): type_ = {"name": "spouse"} with app.app_context(): count = ProductRelationType.query.count() model = ops.create_product_relation_type(type_, self_reverse=True) ops.commit() type_id = model.type_id assert type_id with app.app_context(): assert ProductRelationType.query.count() == (count + 1) model = ProductRelationType.query.filter_by(type_id=type_id).one() assert model.name == "spouse" assert model.reverse is model
def test_update(app): type_id = 1 with app.app_context(): count = ProductRelationType.query.count() model = ops.update_product_relation_type(type_id=type_id, name="renamed") ops.commit() assert model.type_id == type_id with app.app_context(): assert ProductRelationType.query.count() == count model = ProductRelationType.query.filter_by(type_id=type_id).one() assert model.name == "renamed"
def test_create_error(app, field_ids): with app.app_context(): count = ProductType.query.count() with pytest.raises(exc.NoResultFound): model = ops.create_product_type( name="derived_map", field_ids=field_ids, ) ops.commit() with app.app_context(): assert ProductType.query.count() == count model = ProductType.query.filter_by(name="derived_map").one_or_none() assert model is None
def test_delete(app): with app.app_context(): count = ProductRelation.query.count() model = ProductRelation.query.first() relation_id = model.relation_id ops.delete_product_relation(relation_id=relation_id) ops.commit() with app.app_context(): assert ProductRelation.query.count() == (count - 2) model = ProductRelation.query.filter_by( relation_id=relation_id ).one_or_none() assert model is None
def test_delete(app): with app.app_context(): model = ops.create_product_file_path(path="/to/delete") ops.commit() path_id = model.path_id with app.app_context(): count = ProductFilePath.query.count() model = ops.delete_product_file_path(path_id=path_id) ops.commit() with app.app_context(): assert ProductFilePath.query.count() == (count - 1) model = ProductFilePath.query.filter_by(path_id=path_id).one_or_none() assert model is None
def test_create(app): type_ = {"name": "doctor"} reverse = {"name": "patient"} with app.app_context(): count = ProductRelationType.query.count() model = ops.create_product_relation_type(type_, reverse) ops.commit() type_id = model.type_id assert type_id with app.app_context(): assert ProductRelationType.query.count() == (count + 2) model = ProductRelationType.query.filter_by(type_id=type_id).one() assert model.name == "doctor" assert model.reverse.name == "patient"
def test_create(app_empty, type_): app = app_empty with app.app_context(): model = ops.create_field(name="new_field", type_=type_) assert model.name == "new_field" assert model.type_ == FieldType.Float ops.commit() field_id = model.field_id assert field_id with app.app_context(): model = Field.query.filter_by(field_id=field_id).one() assert model.name == "new_field" assert model.type_ == FieldType.Float assert model.field_id == field_id
def test_delete(app): with app.app_context(): model = ops.create_product(type_id=1, name="to_be_deleted") ops.commit() product_id = model.product_id with app.app_context(): count = Product.query.count() model = ops.delete_product(product_id=product_id) ops.commit() with app.app_context(): model = Product.query.filter_by(product_id=product_id).one_or_none() assert model is None assert Product.query.count() == (count - 1)
def test_updated(app): with app.app_context(): count = ProductFilePath.query.count() model = ProductFilePath.query.first() path_id = model.path_id assert model.path != "/new/path" model = ops.update_product_file_path(path_id=path_id, path="/new/path") assert model.path == "/new/path" ops.commit() with app.app_context(): assert ProductFilePath.query.count() == count model = ProductFilePath.query.filter_by(path_id=path_id).one() assert model.path == "/new/path"
def test_delete(app): with app.app_context(): model = ops.create_product_relation_type( type_={"name": "to_be_deleted"}, reverse={"name": "reverse"}, ) ops.commit() type_id = model.type_id with app.app_context(): count = ProductRelationType.query.count() ops.delete_product_relation_type(type_id=type_id) ops.commit() with app.app_context(): assert ProductRelationType.query.count() == count - 2
def test_delete(app): with app.app_context(): model = ops.create_field(name="to_be_deleted", type_=FieldType.Float) ops.commit() field_id = model.field_id with app.app_context(): count = Field.query.count() ret = ops.delete_field(field_id=field_id) ops.commit() assert ret is None with app.app_context(): model = Field.query.filter_by(field_id=field_id).one_or_none() assert model is None assert Field.query.count() == count - 1
def test_delete(app): with app.app_context(): model = ops.create_product_type( name="to_be_deleted", field_ids=[1, 4, 5], ) ops.commit() type_id = model.type_id with app.app_context(): count = ProductType.query.count() model = ops.delete_product_type(type_id=type_id) ops.commit() with app.app_context(): model = ProductType.query.filter_by(type_id=type_id).one_or_none() assert model is None assert ProductType.query.count() == (count - 1)
def app(app_users): y = app_users config_json = json.dumps( { "headTitle": "Head Title", "toolbarTitle": "Toolbar Title", "devtoolLoadingstate": True, "productCreationDialog": False, "productUpdateDialog": True, "productDeletionDialog": True, }, indent=2, ) with y.app_context(): ops.save_web_config(json=config_json) ops.commit() yield y
def app(app_users): y = app_users with y.app_context(): ops.create_field( field_id=1, name="contact", type_=ops.FieldType.UnicodeText, ) ops.create_field( field_id=2, name="produced_by", type_=ops.FieldType.UnicodeText, ) ops.create_field( field_id=3, name="date_produced", type_=ops.FieldType.Date, ) ops.commit() yield y
def test_create(app, field_ids): with app.app_context(): count = ProductType.query.count() model = ops.create_product_type( name="derived_map", field_ids=field_ids, ) assert model.name == "derived_map" ops.commit() type_id = model.type_id assert type_id with app.app_context(): assert ProductType.query.count() == (count + 1) model = ProductType.query.filter_by(type_id=type_id).one() assert model.name == "derived_map" expected_field_ids = sorted(set(field_ids)) if field_ids else [] actual_field_ids = [f.field.field_id for f in model.fields] assert actual_field_ids == expected_field_ids
def app(app_users): y = app_users # map1 -> beam1 # | # +---> beam2 # # map2 # map3 with y.app_context(): ops.create_product_relation_type( type_={ "type_id": 1, "name": "parent" }, reverse={ "type_id": 2, "name": "child" }, ) ops.create_product_type(type_id=1, name="map") ops.create_product_type(type_id=2, name="beam") ops.commit() with y.app_context(): ops.create_product( product_id=1, type_id=1, name="map1", ) ops.create_product( product_id=2, type_id=1, name="map2", ) ops.create_product( product_id=3, type_id=1, name="map3", ) ops.create_product( product_id=4, type_id=2, name="beam1", ) ops.create_product( product_id=5, type_id=2, name="beam2", ) ops.commit() with y.app_context(): ops.create_product_relation( relation_id=2, type_id=1, self_product_id=4, other_product_id=1, ) ops.create_product_relation( relation_id=4, type_id=1, self_product_id=5, other_product_id=4, ) ops.commit() yield y
def app(app_empty): y = app_empty user1 = GitHubUser(login="******", git_hub_id="04:User1") token1 = GitHubToken(token="39d86487d76a84087f1da599c872dac4473e5f07", scope="", user=user1) with y.app_context(): sa.session.add(user1) sa.session.add(token1) sa.session.commit() # map1 -> beam1 # | | # +--------+---> beam2 # # map2 # map3 with y.app_context(): ops.create_product_relation_type( type_={ "type_id": 1, "name": "parent", }, reverse={ "type_id": 2, "name": "child", }, ) ops.commit() with y.app_context(): ops.create_field( field_id=1, name="contact", type_=ops.FieldType.UnicodeText, ) ops.create_field( field_id=2, name="produced_by", type_=ops.FieldType.UnicodeText, ) ops.create_field( field_id=3, name="date_produced", type_=ops.FieldType.Date, ) ops.commit() with y.app_context(): ops.create_product_type( type_id=1, name="map", field_ids=[1, 2, 3], ) ops.create_product_type( type_id=2, name="beam", field_ids=[1, 2, 3], ) ops.commit() with y.app_context(): ops.create_product( type_id=1, product_id=1, name="map1", attributes={3: datetime.date(2020, 2, 1)}, paths=["site1:/path/to/map1", "site2:/another/way/map1"], ) ops.create_product( type_id=1, product_id=2, name="map2", attributes={3: datetime.date(2020, 2, 10)}, paths=["site1:/path/to/map2"], ) ops.create_product( type_id=1, product_id=3, name="map3", attributes={3: datetime.date(2020, 3, 19)}, paths=["site1:/path/to/map3", "site2:/another/way/map3"], ) ops.create_product( type_id=2, product_id=4, name="beam1", attributes={3: datetime.date(2020, 2, 5)}, paths=["site1:/path/to/beam1", "site2:/another/way/beam1"], ) ops.create_product( type_id=2, product_id=5, name="beam2", attributes={3: datetime.date(2020, 3, 4)}, paths=["site1:/path/to/beam2"], ) ops.commit() with y.app_context(): ops.create_product_relation( type_id=1, self_product_id=4, other_product_id=1, ) ops.create_product_relation( type_id=1, self_product_id=5, other_product_id=1, ) ops.create_product_relation( type_id=1, self_product_id=5, other_product_id=4, ) ops.commit() yield y
def _test_create( app, paths=None, relations=None, attributes=None, posting_git_hub_user_id=None, ): kwargs = {"type_id": 1, "name": "new-product"} if paths is not None: kwargs["paths"] = paths if relations is not None: kwargs["relations"] = relations if attributes is not None: kwargs["attributes"] = attributes if posting_git_hub_user_id: kwargs["posting_git_hub_user_id"] = posting_git_hub_user_id with app.app_context(): count = Product.query.count() model = ops.create_product(**kwargs) assert model.name == "new-product" ops.commit() product_id = model.product_id assert product_id with app.app_context(): assert Product.query.count() == (count + 1) model = Product.query.filter_by(product_id=product_id).one() assert model.name == "new-product" if posting_git_hub_user_id: posting_git_hub_user = GitHubUser.query.filter_by( user_id=posting_git_hub_user_id).one() assert model.posting_git_hub_user == posting_git_hub_user else: assert model.posting_git_hub_user is None if paths is not None: expected = _normalize_paths(paths) actual = [p.path for p in model.paths] assert actual == expected else: assert model.paths == [] if relations is not None: expected = [(r["type_id"], r["product_id"]) for r in relations] actual = [(r.type_id, r.other_product_id) for r in model.relations] assert actual == expected else: assert model.relations == [] if attributes is None: attributes = {} expected_ids = [(a.iid, a.field_id) for a in model.type_.fields] # list of (type_field_association.iid, field.field_id) expected = { fid: (aid, attributes.get(fid)) for aid, fid in expected_ids } actual = _extract_attributes(model) # actual_field_ids = list(actual.keys()) assert actual == expected
def _test_update( app, paths=None, relations=None, attributes=None, updating_git_hub_user_id=None, ): product_id = 1 kwargs = {"product_id": product_id, "name": "new-name"} if paths is not None: kwargs["paths"] = paths if relations is not None: kwargs["relations"] = relations if attributes is not None: kwargs["attributes"] = attributes if updating_git_hub_user_id: kwargs["updating_git_hub_user_id"] = updating_git_hub_user_id with app.app_context(): count = Product.query.count() model = Product.query.filter_by(product_id=product_id).one() paths_old = [p.path for p in model.paths] path_ids_old = {p.path: p.path_id for p in model.paths} relations_old = {(r.type_id, r.other_product_id) for r in model.relations} relation_ids_old = {(r.type_id, r.other_product_id): r.relation_id for r in model.relations} attributes_old = _extract_attributes(model) model = ops.update_product(**kwargs) assert model.name == "new-name" ops.commit() with app.app_context(): assert Product.query.count() == count model = Product.query.filter_by(product_id=product_id).one() assert model.name == "new-name" if updating_git_hub_user_id: updating_git_hub_user = GitHubUser.query.filter_by( user_id=updating_git_hub_user_id).one() assert model.updating_git_hub_user == updating_git_hub_user else: assert model.updating_git_hub_user is None # NOTE: The order of the paths is being tested. However, it is # probably not possible to control the order. The order in a # Python list is not preserved once committed in the DB. if paths is not None: kept = [p for p in paths_old if p in paths] expected = kept + _normalize_paths(paths) expected = list(dict.fromkeys(expected)) # uniq order preserved else: expected = paths_old actual = [p.path for p in model.paths] assert actual == expected expected_path_ids = { k: v for k, v in path_ids_old.items() if k in expected } path_ids = { p.path: p.path_id for p in model.paths if p.path in path_ids_old } assert path_ids == expected_path_ids if relations is not None: expected = {(r["type_id"], r["product_id"]) for r in relations} else: expected = relations_old actual = {(r.type_id, r.other_product_id) for r in model.relations} assert actual == expected expected_relation_ids = { k: v for k, v in relation_ids_old.items() if k in expected } relation_ids = {(r.type_id, r.other_product_id): r.relation_id for r in model.relations if (r.type_id, r.other_product_id) in relation_ids_old} assert relation_ids == expected_relation_ids if attributes is None: attributes = {} expected = attributes_old.copy() update = {k: (expected[k][0], v) for k, v in attributes.items()} expected.update(update) actual = _extract_attributes(model) assert actual == expected