def test_with_variables():
assert (
translate("testing.example_with_variables", {"name": "Alice"})
== "Hello, Alice!"
)
assert translate("testing.example_with_variables", {"name": "Bob"}) == "Hello, Bob!"
def test_clin_form_pop_dates_within_contract_dates():
CONTRACT_START_DATE = app.config.get("CONTRACT_START_DATE")
CONTRACT_END_DATE = app.config.get("CONTRACT_END_DATE")
invalid_start = CONTRACT_START_DATE - relativedelta(months=1)
invalid_end = CONTRACT_END_DATE + relativedelta(months=1)
invalid_clin = factories.CLINFactory.create(start_date=invalid_start,
end_date=invalid_end)
clin_form = CLINForm(obj=invalid_clin)
assert not clin_form.validate()
assert (translate(
"forms.task_order.pop_errors.range",
{
"start": CONTRACT_START_DATE.strftime("%b %d, %Y"),
"end": CONTRACT_END_DATE.strftime("%b %d, %Y"),
},
)) in clin_form.start_date.errors
assert (translate(
"forms.task_order.pop_errors.range",
{
"start": CONTRACT_START_DATE.strftime("%b %d, %Y"),
"end": CONTRACT_END_DATE.strftime("%b %d, %Y"),
},
)) in clin_form.end_date.errors
valid_start = CONTRACT_START_DATE + relativedelta(months=1)
valid_end = CONTRACT_END_DATE - relativedelta(months=1)
valid_clin = factories.CLINFactory.create(start_date=valid_start,
end_date=valid_end)
valid_clin_form = CLINForm(obj=valid_clin)
assert valid_clin_form.validate()
class SignatureForm(BaseForm):
signature = BooleanField(
translate("task_orders.sign.digital_signature_description"),
validators=[Required()],
)
confirm = BooleanField(
translate("task_orders.sign.confirmation_description"), validators=[Required()],
)
class NameAndDescriptionForm(BaseForm):
name = StringField(
label=translate("forms.application.name_label"), validators=[Required()]
)
description = TextAreaField(
label=translate("forms.application.description_label"),
validators=[Optional()],
filters=[lambda x: x or None],
)
class CLINForm(FlaskForm):
jedi_clin_type = SelectField(
translate("task_orders.form.clin_type_label"),
choices=JEDI_CLIN_TYPES,
coerce=coerce_enum,
)
number = StringField(label=translate("task_orders.form.clin_number_label"),
validators=[Optional()])
start_date = DateField(
translate("task_orders.form.pop_start"),
description=translate("task_orders.form.pop_example"),
format="%m/%d/%Y",
validators=[validate_date_in_range],
)
end_date = DateField(
translate("task_orders.form.pop_end"),
description=translate("task_orders.form.pop_example"),
format="%m/%d/%Y",
validators=[validate_date_in_range],
)
total_amount = DecimalField(
label=translate("task_orders.form.total_funds_label"),
validators=[
NumberRange(
0,
MAX_CLIN_AMOUNT,
translate(
"forms.task_order.clin_funding_errors.funding_range_error"
),
)
],
)
obligated_amount = DecimalField(
label=translate("task_orders.form.obligated_funds_label"),
validators=[
validate_funding,
NumberRange(
0,
MAX_CLIN_AMOUNT,
translate(
"forms.task_order.clin_funding_errors.funding_range_error"
),
),
],
)
def validate(self, *args, **kwargs):
valid = super().validate(*args, **kwargs)
if (self.start_date.data and self.end_date.data
and self.start_date.data > self.end_date.data):
self.start_date.errors.append(
translate("forms.task_order.pop_errors.date_order"))
valid = False
return valid
class TaskOrderForm(BaseForm):
number = StringField(
label=translate("forms.task_order.number_description"))
pdf = FormField(
AttachmentForm,
label=translate("task_orders.form.supporting_docs_size_limit"),
description=translate("task_orders.form.supporting_docs_size_limit"),
)
clins = FieldList(FormField(CLINForm))
class PortfolioForm(BaseForm):
name = StringField(
translate("forms.portfolio.name_label"),
validators=[
Length(
min=4,
max=100,
message=translate("forms.portfolio.name_length_validation_message"),
)
],
)
def test_clin_form_dollar_amounts_out_of_range():
invalid_clin = factories.CLINFactory.create(
total_amount=-1,
obligated_amount=1000000001,
start_date=datetime.date(2019, 9, 15),
end_date=datetime.date(2020, 9, 14),
)
invalid_clin_form = CLINForm(obj=invalid_clin)
assert not invalid_clin_form.validate()
assert (
translate("forms.task_order.clin_funding_errors.funding_range_error")
) in invalid_clin_form.total_amount.errors
assert (
translate("forms.task_order.clin_funding_errors.funding_range_error")
) in invalid_clin_form.obligated_amount.errors
def formatted_flash(message_name, **message_args):
config = MESSAGES[message_name]
title = translate(config["title"],
message_args) if config["title"] else None
message = translate(config["message"],
message_args) if config["message"] else None
actions = (translate(config["actions"], message_args)
if config.get("actions") else None)
flash({
"title": title,
"message": message,
"actions": actions
}, config["category"])
def test_portfolio_admin_screen_when_ppoc(client, user_session):
portfolio = PortfolioFactory.create()
user_session(portfolio.owner)
response = client.get(url_for("portfolios.admin", portfolio_id=portfolio.id))
assert response.status_code == 200
assert portfolio.name in response.data.decode()
assert translate("fragments.ppoc.update_btn").encode("utf8") in response.data
def ListItemsUnique(
message=translate("forms.validators.list_items_unique_message")):
def _list_items_unique(form, field):
if len(field.data) > len(set(field.data)):
raise ValidationError(message)
return _list_items_unique
def Name(message=translate("forms.validators.name_message")):
def _name(form, field):
match = re.match(r"[\w \,\.\'\-]+", field.data)
if not match or match.group() != field.data:
raise ValidationError(message)
return _name
def do_create_environment(csp: CloudProviderInterface, environment_id=None):
environment = Environments.get(environment_id)
with claim_for_update(environment) as environment:
if environment.cloud_id is not None:
# TODO: Return value for this?
return
user = environment.creator
# we'll need to do some checking in this job for cases where it's retrying
# when a failure occured after some successful steps
# (e.g. if environment.cloud_id is not None, then we can skip first step)
# credentials either from a given user or pulled from config?
# if using global creds, do we need to log what user authorized action?
atat_root_creds = csp.root_creds()
# user is needed because baseline root account in the environment will
# be assigned to the requesting user, open question how to handle duplicate
# email addresses across new environments
csp_environment_id = csp.create_environment(atat_root_creds, user,
environment)
environment.cloud_id = csp_environment_id
db.session.add(environment)
db.session.commit()
body = render_email("emails/application/environment_ready.txt",
{"environment": environment})
app.mailer.send([environment.creator.email],
translate("email.environment_ready"), body)
class EnvironmentsForm(BaseForm):
environment_names = FieldList(
StringField(label=translate("forms.application.environment_names_label")),
validators=[
ListItemRequired(
message=translate(
"forms.application.environment_names_required_validation_message"
)
),
ListItemsUnique(
message=translate(
"forms.application.environment_names_unique_validation_message"
)
),
],
)
def validate_funding(form, field):
if (isinstance(form.total_amount.data, Number)
and isinstance(field.data, Number)
and form.total_amount.data < field.data):
raise ValidationError(
translate(
"forms.task_order.clin_funding_errors.obligated_amount_error"))
def test_home_route(client, user_session):
user = UserFactory.create()
user_session(user)
response = client.get(url_for("atst.home"))
assert response.status_code == 200
assert translate("home.add_portfolio_button_text").encode("utf8") in response.data
def IsNumber(message=translate("forms.validators.is_number_message")):
def _is_number(form, field):
try:
int(field.data)
except (ValueError, TypeError):
raise ValidationError(message)
return _is_number
def send_portfolio_invitation(invitee_email, inviter_name, token):
body = render_template("emails/portfolio/invitation.txt",
owner=inviter_name,
token=token)
send_mail.delay(
[invitee_email],
translate("email.portfolio_invite", {"inviter_name": inviter_name}),
body,
)
def test_portfolio_index_without_existing_portfolios(client, user_session):
user = UserFactory.create()
user_session(user)
response = client.get(url_for("portfolios.portfolios"))
assert response.status_code == 200
assert (translate("portfolios.index.empty.start_button").encode("utf8")
in response.data)
def send_application_invitation(invitee_email, inviter_name, token):
body = render_template("emails/application/invitation.txt",
owner=inviter_name,
token=token)
send_mail.delay(
[invitee_email],
translate("email.application_invite", {"inviter_name": inviter_name}),
body,
)
def ListItemRequired(
message=translate("forms.validators.list_item_required_message"),
empty_values=("", None),
):
def _list_item_required(form, field):
non_empty_values = [v for v in field.data if v not in empty_values]
if len(non_empty_values) == 0:
raise ValidationError(message)
return _list_item_required
def test_portfolio_index_with_existing_portfolios(client, user_session):
portfolio = PortfolioFactory.create()
user_session(portfolio.owner)
response = client.get(url_for("portfolios.portfolios"))
assert response.status_code == 200
assert portfolio.name.encode("utf8") in response.data
assert (translate("portfolios.index.empty.start_button").encode("utf8")
not in response.data)
def validate(self, *args, **kwargs):
valid = super().validate(*args, **kwargs)
if (self.start_date.data and self.end_date.data
and self.start_date.data > self.end_date.data):
self.start_date.errors.append(
translate("forms.task_order.pop_errors.date_order"))
valid = False
return valid
class AttachmentForm(BaseForm):
filename = HiddenField(
id="attachment_filename",
validators=[
Length(max=100, message=translate("forms.attachment.filename.length_error"))
],
)
object_name = HiddenField(
id="attachment_object_name",
validators=[
Length(
max=40, message=translate("forms.attachment.object_name.length_error")
)
],
)
accept = ".pdf,application/pdf"
def validate(self, *args, **kwargs):
return super().validate(*args, **{**kwargs, "flash_invalid": False})
class NewForm(FlaskForm):
first_name = StringField(
label=translate("forms.new_member.first_name_label"), validators=[Required()]
)
last_name = StringField(
label=translate("forms.new_member.last_name_label"), validators=[Required()]
)
email = EmailField(
translate("forms.new_member.email_label"), validators=[Required(), Email()]
)
phone_number = TelField(
translate("forms.new_member.phone_number_label"),
validators=[Optional(), PhoneNumber()],
)
phone_ext = StringField("Extension")
dod_id = StringField(
translate("forms.new_member.dod_id_label"),
validators=[Required(), Length(min=10), IsNumber()],
)
def PhoneNumber(message=translate("forms.validators.phone_number_message")):
def _is_phone_number(form, field):
digits = re.sub(r"\D", "", field.data)
if len(digits) not in [5, 10]:
raise ValidationError(message)
match = re.match(r"[\d\-\(\) ]+", field.data)
if not match or match.group() != field.data:
raise ValidationError(message)
return _is_phone_number
def ListItemRequired(
message=translate("forms.validators.list_item_required_message"),
empty_values=[None],
):
def _list_item_required(form, field):
non_empty_values = [
v for v in field.data if (v not in empty_values and re.search(r"\S", v))
]
if len(non_empty_values) == 0:
raise ValidationError(message)
return _list_item_required
def test_clin_form_obligated_greater_than_total():
invalid_clin = factories.CLINFactory.create(
total_amount=0,
obligated_amount=1,
start_date=datetime.date(2019, 9, 15),
end_date=datetime.date(2020, 9, 14),
)
invalid_clin_form = CLINForm(obj=invalid_clin)
assert not invalid_clin_form.validate()
assert (
translate("forms.task_order.clin_funding_errors.obligated_amount_error"
)) in invalid_clin_form.obligated_amount.errors
class PortfolioCreationForm(PortfolioForm):
defense_component = SelectMultipleField(
choices=SERVICE_BRANCHES,
widget=ListWidget(prefix_label=False),
option_widget=CheckboxInput(),
validators=[
InputRequired(
message=translate(
"forms.portfolio.defense_component.validation_message"
)
)
],
)
def test_portfolio_admin_screen_when_not_ppoc(client, user_session):
portfolio = PortfolioFactory.create()
user = UserFactory.create()
permission_sets = PermissionSets.get_many(
[PermissionSets.EDIT_PORTFOLIO_ADMIN, PermissionSets.VIEW_PORTFOLIO_ADMIN]
)
PortfolioRoleFactory.create(
portfolio=portfolio, user=user, permission_sets=permission_sets
)
user_session(user)
response = client.get(url_for("portfolios.admin", portfolio_id=portfolio.id))
assert response.status_code == 200
assert portfolio.name in response.data.decode()
assert translate("fragments.ppoc.update_btn").encode("utf8") not in response.data
