def test_parse_legacy_contract_items(self):
raw_contract_items = [get_fixture("contract-item-legacy")]
parsed_contract_items = parse_contract_items(
raw_items=raw_contract_items)
expectation = [
ContractItem(
id=6,
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
created_at="2014-01-01T10:00:00Z",
start_date="2014-01-01T10:00:00Z",
end_date="2015-01-01T00:00:00Z",
reason="contract_created",
value=5,
product_listing_id=None,
purchase_id=None,
trial_id=None,
renewal=Renewal(
id="rAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
actionable=True,
start_date="2014-11-01T00:00:00Z",
end_date="2015-01-01T00:00:00Z",
status="pending",
new_contract_start="2015-01-01T00:00:00Z",
price=5000,
currency="USD",
),
),
]
self.assertIsInstance(parsed_contract_items, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_contract_items))
def test_parse_users(self):
raw_users = get_fixture("users")
parsed_users = parse_users(raw_users)
joe = User(
display_name="Joe Doe",
name="joedoe2021",
email="*****@*****.**",
id="aAbBcCdD",
last_login_at="2021-09-10T12:00:00Z",
first_login_at="2021-09-10T12:00:00Z",
verified=True,
)
joe.set_user_role_on_account("admin")
expectation = [
joe,
User(
display_name="Jane Doe",
name="janedoe2021",
email="*****@*****.**",
id="aAbBcCdD2",
last_login_at="2021-09-10T12:00:00Z",
first_login_at="2021-09-10T12:00:00Z",
verified=False,
),
]
self.assertEqual(to_dict(parsed_users), to_dict(expectation))
def test_parse_entitlements(self):
raw_entitlements = get_fixture("entitlements")
parsed_entitlements = parse_entitlements(
raw_entitlements=raw_entitlements)
expectation = [
Entitlement(
type="entitlement-type",
support_level=None,
enabled_by_default=True,
is_available=True,
),
Entitlement(
type="entitlement-type-2",
support_level=None,
enabled_by_default=False,
is_available=True,
),
Entitlement(
type="support",
support_level="advanced",
enabled_by_default=False,
is_available=True,
),
]
self.assertIsInstance(parsed_entitlements, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_entitlements))
def test_parse_offers(self):
raw_offers = get_fixture("offers")
parsed_offers = parse_offers(raw_offers)
expectation = [
Offer(
id="oOaAbBcCdDeEfFgG",
account_id="aAbBcCdDeEfFgG",
total=810000,
actionable=True,
created_at="2022-01-04T10:00:00Z",
marketplace="canonical-ua",
items=[
OfferItem(
id="lAaBbCcDdEeFfGg",
name="uai-advanced-desktop-oneoff",
price=60000,
allowance=2,
),
OfferItem(
id="lAaBbCcDdEeFfGg-2",
name="uai-advanced-physical-oneoff",
price=750000,
allowance=5,
),
],
)
]
self.assertIsInstance(parsed_offers, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_offers))
def test_parse_subscription(self):
raw_subscription = get_fixture("subscription")
parsed_subscription = parse_subscription(
raw_subscription=raw_subscription)
expectation = Subscription(
id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
account_id="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
marketplace="canonical-ua",
period="yearly",
status="active",
last_purchase_id="pAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
pending_purchases=["pAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP222"],
items=[
SubscriptionItem(
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
value=3,
),
],
started_with_trial=True,
in_trial=True,
)
self.assertIsInstance(parsed_subscription, Subscription)
self.assertEqual(to_dict(expectation), to_dict(parsed_subscription))
def test_returns_list_of_accounts(self):
session = Session(
Response(
status_code=200,
content={"accounts": get_fixture("accounts")},
))
ua_contracts_api = make_client(session)
advantage_mapper = AdvantageMapper(ua_contracts_api)
response = advantage_mapper.get_accounts()
self.assertIsInstance(response, List)
for item in response:
self.assertIsInstance(item, Account)
expectation = [
Account(
id="a123AbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
name="Free",
role="admin",
),
Account(
id="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
name="Account Name",
role="admin",
),
]
self.assertEqual(to_dict(expectation), to_dict(response))
def test_parse_listings(self):
raw_products = get_fixture("products")
raw_product_listings = get_fixture("product-listings")
parsed_listings = parse_product_listings(
raw_product_listings=raw_product_listings,
raw_products=raw_products,
)
expectation = {
"lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2":
Listing(
id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
name="product-id-2",
marketplace="canonical-ua",
status="active",
product=Product(
name="Product Name 2",
id="product-id-2",
),
price=1000,
currency="USD",
trial_days=None,
period=None,
)
}
self.assertIsInstance(parsed_listings, Dict)
self.assertEqual(to_dict(expectation), to_dict(parsed_listings))
def test_parse_subscriptions(self):
raw_subscriptions = get_fixture("subscriptions")
parsed_subscriptions = parse_subscriptions(
raw_subscriptions=raw_subscriptions)
expectation = [
Subscription(
id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
account_id="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
marketplace="canonical-ua",
period="monthly",
status="active",
last_purchase_id="pAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
is_auto_renewing=True,
items=[
SubscriptionItem(
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
value=3,
),
],
started_with_trial=None,
),
]
self.assertIsInstance(parsed_subscriptions, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_subscriptions))
def test_parse_no_contract_items(self):
parsed_contract_items = parse_contract_items(None)
self.assertIsInstance(parsed_contract_items, List)
self.assertEqual([], to_dict(parsed_contract_items))
parsed_contract_items = parse_contract_items([])
self.assertIsInstance(parsed_contract_items, List)
self.assertEqual([], to_dict(parsed_contract_items))
def test_parse_no_entitlements(self):
parsed_entitlements = parse_entitlements(None)
self.assertIsInstance(parsed_entitlements, List)
self.assertEqual([], to_dict(parsed_entitlements))
parsed_entitlements = parse_entitlements([])
self.assertIsInstance(parsed_entitlements, List)
self.assertEqual([], to_dict(parsed_entitlements))
def test_parse_no_subscription_items(self):
subscription_id = "random-id"
parsed_subscription_items = parse_subscription_items(
subscription_id, None)
self.assertIsInstance(parsed_subscription_items, List)
self.assertEqual([], to_dict(parsed_subscription_items))
parsed_subscription_items = parse_subscription_items(
subscription_id, [])
self.assertIsInstance(parsed_subscription_items, List)
self.assertEqual([], to_dict(parsed_subscription_items))
def test_parse_product(self):
raw_product = get_fixture("product")
parsed_product = parse_product(raw_product=raw_product)
expectation = Product(
id="product-id",
name="Product Name",
)
self.assertIsInstance(parsed_product, Product)
self.assertEqual(to_dict(expectation), to_dict(parsed_product))
def test_parse_contract(self):
raw_contract = get_fixture("contract")
parsed_contract = parse_contract(raw_contract=raw_contract)
expectation = Contract(
id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
account_id="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
name="Product Name",
product_id="product-id",
entitlements=[
Entitlement(
type="entitlement-type-2",
support_level=None,
enabled_by_default=False,
),
Entitlement(
type="support",
support_level="advanced",
enabled_by_default=False,
),
],
number_of_active_machines=0,
items=[
ContractItem(
id=10,
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
created_at="2017-01-02T10:00:00Z",
start_date="2017-01-02T10:00:00Z",
end_date="2018-01-02T10:00:00Z",
reason="trial_started",
value=1,
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
purchase_id=None,
trial_id="tAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
),
ContractItem(
id=11,
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
created_at="2017-02-02T10:00:00Z",
start_date="2017-02-02T10:00:00Z",
end_date="2018-02-02T10:00:00Z",
reason="purchase_made",
value=1,
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
purchase_id="pAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
trial_id=None,
),
],
)
self.assertIsInstance(parsed_contract, Contract)
self.assertEqual(to_dict(expectation), to_dict(parsed_contract))
def test_returns_3ds_purchase(self):
session = Session(
Response(
status_code=200,
content=get_fixture("purchase-3ds"),
))
ua_contracts_api = make_client(session)
advantage_mapper = AdvantageMapper(ua_contracts_api)
response = advantage_mapper.get_purchase("pAaBbCcDd")
self.assertIsInstance(response, Purchase)
expected_invoice = Invoice(
reason="subscription_create",
currency="usd",
status="open",
total=27000,
id="in_aAaBbCcDd",
items=[{
"currency":
"usd",
"description": ("1 machine x UA Infrastructure"
" - Essential (Physical) (at $225.00 / year)"),
"pro_rated_amount":
22500,
"quantity":
1,
}],
tax_amount=4500,
payment_status={
"pi_client_secret": "pi_aAbBcCdD",
"status": "need_3ds_authorization",
},
url="download.link",
)
self.assertEqual(to_dict(expected_invoice), to_dict(response.invoice))
expected_purchase = Purchase(
id="pAaBbCcDd",
account_id="aAaBbCcDd",
subscription_id="sAaBbCcDd",
marketplace="canonical-ua",
created_at="2022-02-23T13:46:05.871Z",
status="processing",
invoice=expected_invoice,
items=[PurchaseItem(
listing_id="lAaBbCcDd",
value=1,
)],
)
self.assertEqual(to_dict(expected_purchase), to_dict(response))
def test_apply_entitlement_rules_is_available(self):
entitlements = [
Entitlement(
type="landscape",
enabled_by_default=False,
),
Entitlement(
type="support",
enabled_by_default=False,
support_level="standard",
),
Entitlement(
type="esm-infra",
enabled_by_default=True,
),
]
final_entitlements = apply_entitlement_rules(entitlements)
expected_entitlements = [
Entitlement(
type="support",
support_level="standard",
enabled_by_default=True,
is_available=True,
is_editable=False,
),
Entitlement(
type="esm-infra",
enabled_by_default=True,
),
Entitlement(
type="esm-apps",
enabled_by_default=False,
is_available=False,
is_editable=False,
),
Entitlement(
type="support",
support_level="advanced",
enabled_by_default=False,
is_available=False,
is_editable=False,
),
]
self.assertEqual(to_dict(final_entitlements),
to_dict(expected_entitlements))
def test_parse_user(self):
raw_user = get_fixture("user")
parsed_user = parse_user(raw_user)
expectation = User(
display_name="Joe Doe",
name="joedoe2021",
email="*****@*****.**",
id="aAbBcCdD",
last_login_at="2021-09-10T12:00:00Z",
first_login_at="2021-09-10T12:00:00Z",
verified=True,
)
self.assertEqual(to_dict(parsed_user), to_dict(expectation))
def post_advantage_purchase(advantage_mapper: AdvantageMapper, **kwargs):
account_id = kwargs.get("account_id")
customer_info = kwargs.get("customer_info")
marketplace = kwargs.get("marketplace", "canonical-ua")
if account_id is None:
try:
account = advantage_mapper.get_or_create_user_account(
marketplace, customer_info, kwargs.get("captcha_value")
)
account_id = account.id
if account.token is not None:
flask.session["guest_authentication_token"] = account.token
except AccessForbiddenError:
response = {"error": "User has no permission to purchase"}
return flask.jsonify(response), 403
response = advantage_mapper.post_user_purchase(
account_id=account_id,
marketplace=marketplace,
customer_info=customer_info,
action=kwargs.get("action", "purchase"),
products=kwargs.get("products", []),
offer_id=kwargs.get("offer_id"),
previous_purchase_id=kwargs.get("previous_purchase_id"),
session=flask.session,
preview=kwargs.get("preview"),
)
return flask.jsonify(to_dict(response)), 200
def blender_shop_view(advantage_mapper, **kwargs):
account = None
if user_info(flask.session):
try:
account = advantage_mapper.get_purchase_account("blender")
except UAContractsUserHasNoAccount:
# There is no purchase account yet for this user.
# One will need to be created later; expected condition.
pass
except AccessForbiddenError:
return flask.render_template("account/forbidden.html")
all_subscriptions = []
if account:
all_subscriptions = advantage_mapper.get_account_subscriptions(
account_id=account.id,
marketplace="blender",
)
current_subscriptions = [
subscription
for subscription in all_subscriptions
if subscription.status in ["active", "locked"]
]
listings = advantage_mapper.get_product_listings("blender")
previous_purchase_ids = extract_last_purchase_ids(current_subscriptions)
return flask.render_template(
"advantage/subscribe/blender/index.html",
account=account,
previous_purchase_ids=previous_purchase_ids,
product_listings=to_dict(listings),
)
def test_returns_purchase(self):
session = Session(
Response(
status_code=200,
content=get_fixture("purchase"),
))
ua_contracts_api = make_client(session)
advantage_mapper = AdvantageMapper(ua_contracts_api)
response = advantage_mapper.get_purchase("pAaBbCcDd")
self.assertIsInstance(response, Purchase)
expected_invoice = Invoice(
reason="subscription_update",
currency="usd",
status="open",
total=1200,
id="in_abcdef",
items=[{
"currency": "usd",
"description": "Description",
"pro_rated_amount": 1000,
"quantity": 1,
}],
tax_amount=200,
payment_status={
"error": "generic_decline",
"status": "need_another_payment_method",
},
url="invoice.url",
)
self.assertEqual(to_dict(expected_invoice), to_dict(response.invoice))
expected_purchase = Purchase(
id="pAaBbCcDd",
account_id="aAaBbCcDdEeFfGg",
subscription_id="sAaBbCcDdEeFfGg",
marketplace="canonical-ua",
created_at="2020-01-01T10:00:00Z",
status="processing",
invoice=expected_invoice,
items=[PurchaseItem(
listing_id="lAaBbCcDdEeFfGg",
value=1,
)],
)
self.assertEqual(to_dict(expected_purchase), to_dict(response))
def test_parse_renewal(self):
raw_renewal = get_fixture("renewal")
parsed_renewal = parse_renewal(raw_renewal=raw_renewal)
expectation = Renewal(
id="rAaBbCcDdEeFf",
contract_id="cAaBbCcDdEeFf",
actionable=False,
start_date="2020-11-01T00:00:00Z",
end_date="2021-01-01T00:00:00Z",
status="done",
new_contract_start="2021-01-01T00:00:00Z",
price=11000,
currency="USD",
)
self.assertEqual(to_dict(expectation), to_dict(parsed_renewal))
def test_apply_entitlement_rules_is_enabled(self):
entitlements = [
Entitlement(
type="livepatch",
enabled_by_default=True,
),
Entitlement(
type="fips-updates",
enabled_by_default=True,
),
Entitlement(
type="fips",
enabled_by_default=True,
),
Entitlement(
type="esm-apps",
enabled_by_default=True,
),
]
final_entitlements = apply_entitlement_rules(entitlements)
expected_entitlements = [
Entitlement(
type="livepatch",
enabled_by_default=False,
is_editable=False,
),
Entitlement(
type="fips-updates",
enabled_by_default=False,
is_editable=False,
),
Entitlement(
type="fips",
enabled_by_default=True,
),
Entitlement(
type="esm-apps",
enabled_by_default=True,
),
]
self.assertEqual(to_dict(final_entitlements),
to_dict(expected_entitlements))
def test_parses_entitlement_without_obligations(self):
raw_entitlements = ('[{"type": "support", "entitled": true, '
'"affordances": {"supportLevel": "essential"}}]')
parsed_entitlements = parse_entitlements(
raw_entitlements=json.loads(raw_entitlements))
expected_entitlements = [
Entitlement(
type="support",
support_level="essential",
enabled_by_default=False,
is_available=True,
),
]
self.assertEqual(to_dict(parsed_entitlements),
to_dict(expected_entitlements))
def test_returns_purchase_account(self):
session = Session(
Response(
status_code=200,
content=get_fixture("account"),
))
ua_contracts_api = make_client(session)
advantage_mapper = AdvantageMapper(ua_contracts_api)
response = advantage_mapper.get_purchase_account("canonical-ua")
self.assertIsInstance(response, Account)
expectation = Account(
id="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
name="Account Name",
role="admin",
)
self.assertEqual(to_dict(expectation), to_dict(response))
def test_parse_listings_with_no_listings(self):
raw_products = None
raw_product_listings = None
parsed_listings = parse_product_listings(
raw_product_listings=raw_product_listings,
raw_products=raw_products,
)
self.assertIsInstance(parsed_listings, Dict)
self.assertEqual({}, to_dict(parsed_listings))
def test_parse_listing_with_no_product(self):
raw_products = []
raw_product_listing = get_fixture("product-listing")
parsed_listing = parse_product_listing(
raw_product_listing=raw_product_listing,
raw_products=raw_products,
)
expectation = Listing(
id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
name="product-id",
marketplace="canonical-ua",
product=None,
price=1000,
currency="USD",
status="active",
trial_days=20,
period=None,
)
self.assertIsInstance(parsed_listing, Listing)
self.assertEqual(to_dict(expectation), to_dict(parsed_listing))
def test_parse_trial_contract_items(self):
raw_contract_items = [get_fixture("contract-item-trial")]
parsed_contract_items = parse_contract_items(
raw_items=raw_contract_items)
expectation = [
ContractItem(
id=5,
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
created_at="2014-06-01T10:00:00Z",
start_date="2014-06-01T10:00:00Z",
end_date="2015-07-01T00:00:00Z",
reason="trial_started",
value=1,
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP23",
purchase_id=None,
trial_id="tAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
)
]
self.assertIsInstance(parsed_contract_items, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_contract_items))
def test_parse_offer_items(self):
raw_offer = get_fixture("offer")
parsed_offer_items = parse_offer_items(raw_offer["items"],
raw_offer["productListings"])
expectation = [
OfferItem(
id="lAaBbCcDdEeFfGg",
name="uai-advanced-desktop-oneoff",
price=60000,
allowance=2,
),
OfferItem(
id="lAaBbCcDdEeFfGg-2",
name="uai-advanced-physical-oneoff",
price=750000,
allowance=5,
),
]
self.assertIsInstance(parsed_offer_items, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_offer_items))
def test_parse_subscription_items(self):
raw_subscription_items = get_fixture("subscription-items")
parsed_subscription_items = parse_subscription_items(
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
raw_items=raw_subscription_items,
)
expectation = [
SubscriptionItem(
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
value=4,
),
SubscriptionItem(
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP",
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
value=2,
),
]
self.assertIsInstance(parsed_subscription_items, List)
self.assertEqual(to_dict(expectation),
to_dict(parsed_subscription_items))
def get_account_users(advantage_mapper, **kwargs):
try:
account = advantage_mapper.get_purchase_account("canonical-ua")
except UAContractsUserHasNoAccount:
return flask.jsonify({"errors": "cannot find purchase account"}), 404
account_users = advantage_mapper.get_account_users(account_id=account.id)
return flask.jsonify(
{
"account_id": account.id,
"name": account.name,
"users": to_dict(account_users),
}
)
def test_parse_purchase_contract_items(self):
raw_contract_items = [get_fixture("contract-item-shop")]
parsed_contract_items = parse_contract_items(
raw_items=raw_contract_items)
expectation = [
ContractItem(
id=3,
contract_id="cAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
created_at="2014-02-01T10:00:00Z",
start_date="2014-03-01T10:00:00Z",
end_date="2015-03-01T00:00:00Z",
reason="purchase_made",
value=1,
product_listing_id="lAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
subscription_id="sAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
purchase_id="pAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP2",
trial_id=None,
),
]
self.assertIsInstance(parsed_contract_items, List)
self.assertEqual(to_dict(expectation), to_dict(parsed_contract_items))
