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))