class TestReference(TestCase):
fixtures = fixture('user_999')
def setUp(self):
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
@patch('mkt.developers.models.client')
def test_setup_seller(self, client):
self.ref.setup_seller(self.user)
ok_(SolitudeSeller.objects.filter(user=self.user).exists())
@patch('mkt.developers.models.client')
@patch.object(Reference, 'client')
def test_account_create(self, providers, models):
data = {'account_name': 'account', 'name': 'f', 'email': '*****@*****.**'}
res = self.ref.account_create(self.user, data)
acct = PaymentAccount.objects.get(user=self.user)
eq_(acct.provider, PROVIDER_REFERENCE)
eq_(res.pk, acct.pk)
def test_check(self):
provider = Reference()
@account_check
def test(self, account):
pass
provider.test = test
provider.test(provider, PaymentAccount(provider=PROVIDER_REFERENCE))
with self.assertRaises(ValueError):
provider.test(provider, PaymentAccount(provider=PROVIDER_BOKU))
def get_or_create_payment_account(email='*****@*****.**',
name='Fake App Developer'):
user, _ = UserProfile.objects.get_or_create(
email=email,
source=mkt.LOGIN_SOURCE_UNKNOWN,
display_name=name)
try:
acct = PaymentAccount.objects.get(user=user)
except PaymentAccount.DoesNotExist:
acct = Reference().account_create(
user, {'account_name': name, 'name': name, 'email': email})
return acct
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
class TestReference(Patcher, TestCase):
fixtures = fixture('user_999')
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
def test_setup_seller(self):
self.ref.setup_seller(self.user)
ok_(SolitudeSeller.objects.filter(user=self.user).exists())
def test_account_create(self):
data = {'account_name': 'account', 'name': 'f', 'email': '*****@*****.**'}
res = self.ref.account_create(self.user, data)
acct = PaymentAccount.objects.get(user=self.user)
eq_(acct.provider, PROVIDER_REFERENCE)
eq_(res.pk, acct.pk)
self.ref_patcher.sellers.post.assert_called_with(data={
'status': 'ACTIVE',
'email': '*****@*****.**',
'uuid': ANY,
'name': 'f',
})
def make_account(self):
seller = SolitudeSeller.objects.create(user=self.user)
return PaymentAccount.objects.create(user=self.user,
solitude_seller=seller,
uri='/f/b/1',
name='account name')
def test_terms_retrieve(self):
account = self.make_account()
self.ref.terms_retrieve(account)
assert self.ref_patcher.terms.called
def test_terms_bleached(self):
account = self.make_account()
account_mock = Mock()
account_mock.get.return_value = {
'text': '<script>foo</script><a>bar</a>'
}
self.ref_patcher.terms.return_value = account_mock
eq_(
self.ref.terms_retrieve(account)['text'],
u'<script>foo</script><a>bar</a>')
def test_terms_update(self):
seller_mock = Mock()
seller_mock.get.return_value = {
'id': 1,
'resource_uri': '/a/b/c',
'resource_name': 'x',
'initial_field': u'initial content',
}
seller_mock.put.return_value = {}
self.ref_patcher.sellers.return_value = seller_mock
account = self.make_account()
self.ref.terms_update(account)
eq_(account.reload().agreed_tos, True)
assert self.ref_patcher.sellers.called
seller_mock.get.assert_called_with()
seller_mock.put.assert_called_with({
'agreement':
datetime.now().strftime('%Y-%m-%d'),
'initial_field':
u'initial content',
})
def test_account_retrieve(self):
account = self.make_account()
acc = self.ref.account_retrieve(account)
eq_(acc, {'account_name': 'account name'})
assert self.ref_patcher.sellers.called
def test_account_update(self):
account_data = {
'status': '',
'resource_name': 'sellers',
'uuid': 'custom-uuid',
'agreement': '',
'email': '*****@*****.**',
'id': 'custom-uuid',
'resource_uri': '/provider/reference/sellers/custom-uuid/',
'account_name': u'Test',
'name': 'Test',
}
seller_mock = Mock()
seller_mock.get.return_value = account_data
self.ref_patcher.sellers.return_value = seller_mock
account = self.make_account()
self.ref.account_update(account, account_data)
eq_(self.ref.forms['account']().hidden_fields()[0].name, 'uuid')
eq_(account.reload().name, 'Test')
seller_mock.put.assert_called_with(account_data)
def test_product_create_exists(self):
self.ref_patcher.products.get.return_value = [{'resource_uri': '/f'}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
# Product should have been got from zippy, but not created by a post.
assert self.ref_patcher.products.get.called
@raises(ValueError)
def test_product_mulitple(self):
self.ref_patcher.products.get.return_value = [{}, {}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
def test_product_create_not(self):
self.generic_patcher.product.get_object_or_404.return_value = {
'external_id': 'ext'
}
self.ref_patcher.products.get.return_value = []
self.ref_patcher.products.post.return_value = {'resource_uri': '/f'}
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
self.ref_patcher.products.get.assert_called_with(seller_id='1',
external_id='ext')
self.ref_patcher.products.post.assert_called_with(
data={
'seller_id': '1',
'external_id': 'ext',
'name': unicode(app.name),
'uuid': ANY,
})
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
class TestReference(Patcher, TestCase):
fixtures = fixture('user_999')
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
def test_setup_seller(self):
self.ref.setup_seller(self.user)
ok_(SolitudeSeller.objects.filter(user=self.user).exists())
def test_account_create(self):
data = {'account_name': 'account', 'name': 'f', 'email': '*****@*****.**'}
res = self.ref.account_create(self.user, data)
acct = PaymentAccount.objects.get(user=self.user)
eq_(acct.provider, PROVIDER_REFERENCE)
eq_(res.pk, acct.pk)
self.ref_patcher.sellers.post.assert_called_with(data={
'status': 'ACTIVE',
'email': '*****@*****.**',
'uuid': ANY,
'name': 'f',
})
def make_account(self):
seller = SolitudeSeller.objects.create(user=self.user)
return PaymentAccount.objects.create(user=self.user,
solitude_seller=seller,
uri='/f/b/1',
name='account name',
provider=PROVIDER_REFERENCE)
def test_terms_retrieve(self):
account = self.make_account()
self.ref.terms_retrieve(account)
assert self.ref_patcher.terms.called
def test_terms_bleached(self):
account = self.make_account()
account_mock = Mock()
account_mock.get.return_value = {'text':
'<script>foo</script><a>bar</a>'}
self.ref_patcher.terms.return_value = account_mock
eq_(self.ref.terms_retrieve(account)['text'],
u'<script>foo</script><a>bar</a>')
def test_terms_update(self):
seller_mock = Mock()
seller_mock.get.return_value = {
'id': 1,
'resource_uri': '/a/b/c',
'resource_name': 'x',
'initial_field': u'initial content',
}
seller_mock.put.return_value = {}
self.ref_patcher.sellers.return_value = seller_mock
account = self.make_account()
self.ref.terms_update(account)
eq_(account.reload().agreed_tos, True)
assert self.ref_patcher.sellers.called
seller_mock.get.assert_called_with()
seller_mock.put.assert_called_with({
'agreement': datetime.now().strftime('%Y-%m-%d'),
'initial_field': u'initial content',
})
def test_account_retrieve(self):
account = self.make_account()
acc = self.ref.account_retrieve(account)
eq_(acc, {'account_name': 'account name'})
assert self.ref_patcher.sellers.called
def test_account_update(self):
account_data = {
'status': '',
'resource_name': 'sellers',
'uuid': 'custom-uuid',
'agreement': '',
'email': '*****@*****.**',
'id': 'custom-uuid',
'resource_uri': '/provider/reference/sellers/custom-uuid/',
'account_name': u'Test',
'name': 'Test',
}
seller_mock = Mock()
seller_mock.get.return_value = account_data
self.ref_patcher.sellers.return_value = seller_mock
account = self.make_account()
self.ref.account_update(account, account_data)
eq_(self.ref.forms['account']().hidden_fields()[0].name, 'uuid')
eq_(account.reload().name, 'Test')
seller_mock.put.assert_called_with(account_data)
def test_product_create_exists(self):
self.ref_patcher.products.get.return_value = [{'resource_uri': '/f'}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
# Product should have been got from zippy, but not created by a post.
assert self.ref_patcher.products.get.called
@raises(ValueError)
def test_product_mulitple(self):
self.ref_patcher.products.get.return_value = [{}, {}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
def test_product_create_not(self):
self.generic_patcher.product.get_object_or_404.return_value = {
'external_id': 'ext'}
self.ref_patcher.products.get.return_value = []
self.ref_patcher.products.post.return_value = {'resource_uri': '/f'}
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
self.ref_patcher.products.get.assert_called_with(
seller_id='1', external_id='ext')
self.ref_patcher.products.post.assert_called_with(data={
'seller_id': '1',
'external_id': 'ext',
'name': unicode(app.name),
'uuid': ANY,
})
class TestReference(Patcher, TestCase):
fixtures = fixture('user_999')
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
def test_setup_seller(self):
self.ref.setup_seller(self.user)
ok_(SolitudeSeller.objects.filter(user=self.user).exists())
def test_account_create(self):
data = {'account_name': 'account', 'name': 'f', 'email': '*****@*****.**'}
res = self.ref.account_create(self.user, data)
acct = PaymentAccount.objects.get(user=self.user)
eq_(acct.provider, PROVIDER_REFERENCE)
eq_(res.pk, acct.pk)
def make_account(self):
seller = SolitudeSeller.objects.create(user=self.user)
return PaymentAccount.objects.create(user=self.user,
solitude_seller=seller,
uri='/f/b/1')
def test_terms_retrieve(self):
account = self.make_account()
self.ref.terms_retrieve(account)
assert self.ref_patcher.terms.called
def test_terms_update(self):
account = self.make_account()
self.ref.terms_update(account)
eq_(account.reload().agreed_tos, True)
assert self.ref_patcher.sellers.called
def test_account_retrieve(self):
account = self.make_account()
self.ref.account_retrieve(account)
assert self.ref_patcher.sellers.called
def test_account_update(self):
account = self.make_account()
self.ref.account_update(account, {'account_name': 'foo'})
eq_(account.reload().name, 'foo')
assert self.ref_patcher.sellers.called
def test_product_create_exists(self):
self.ref_patcher.products.get.return_value = [{'resource_uri': '/f'}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
# Product should have been got from zippy, but not created by a post.
assert self.ref_patcher.products.get.called
@raises(ValueError)
def test_product_mulitple(self):
self.ref_patcher.products.get.return_value = [{}, {}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
def test_product_create_not(self):
self.generic_patcher.product.get_object_or_404.return_value = {
'external_id': 'ext'}
self.ref_patcher.products.get.return_value = []
self.ref_patcher.products.post.return_value = {'resource_uri': '/f'}
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
self.ref_patcher.products.get.assert_called_with(
seller_id='1', external_id='ext')
self.ref_patcher.products.post.assert_called_with(data={
'seller_id': '1', 'external_id': 'ext', 'name': unicode(app.name)})
def setUp(self):
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
def generate_app_from_spec(name, categories, type, status, num_previews=1,
num_ratings=1, locale_names=('en-US', 'es-ES'),
preview_files=(),
video_files=(),
developer_name='Fake App Developer',
developer_email='*****@*****.**',
privacy_policy='Fake privacy policy',
premium_type='free', description=None,
default_locale='en-US', rereview=False,
special_regions={}, inapp_id=None,
inapp_secret=None, popularity=0, tarako=False,
**spec):
status = STATUS_CHOICES_API_LOOKUP[status]
names = generate_localized_names(name, locale_names)
if type == 'hosted':
app = generate_hosted_app(
names[default_locale], categories, developer_name, status=status,
default_locale=default_locale, **spec)
else:
app = generate_packaged_app(
names, type, categories, developer_name,
default_locale=default_locale, status=status, **spec)
generate_icon(app)
if not preview_files:
generate_previews(app, num_previews)
if video_files:
for i, f in enumerate(video_files):
t = tempfile.mktemp()
copy_stored_file(f, t, src_storage=local_storage,
dst_storage=private_storage)
p = Preview.objects.create(addon=app, filetype="video/webm",
caption="video " + str(i),
position=i)
resize_video(t, p.pk)
if preview_files:
for i, f in enumerate(preview_files):
p = Preview.objects.create(addon=app, filetype="image/png",
caption="screenshot " + str(i),
position=i + len(video_files))
t = tempfile.mktemp()
copy_stored_file(f, t, src_storage=local_storage,
dst_storage=private_storage)
resize_preview(t, p.pk)
generate_ratings(app, num_ratings)
app.name = names
if not description:
description = GENERIC_DESCRIPTION
app.description = description
app.privacy_policy = privacy_policy
app.support_email = developer_email
premium_type = mkt.ADDON_PREMIUM_API_LOOKUP[premium_type]
app.premium_type = premium_type
app.default_locale = default_locale
if popularity:
app.popularity.create(value=popularity)
if premium_type != mkt.ADDON_FREE and status != mkt.STATUS_NULL:
acct = get_or_create_payment_account(developer_email, developer_name)
product_uri = Reference().product_create(acct, app)
AddonPaymentAccount.objects.create(addon=app, payment_account=acct,
account_uri=acct.uri,
product_uri=product_uri)
if premium_type in (mkt.ADDON_PREMIUM, mkt.ADDON_PREMIUM_INAPP):
price = get_or_create_price(spec.get('price', '0.99'))
AddonPremium.objects.create(addon=app, price=price)
if premium_type in (mkt.ADDON_FREE_INAPP, mkt.ADDON_PREMIUM_INAPP):
UserInappKey.create(acct.user, secret=inapp_secret,
public_id=inapp_id,
access_type=ACCESS_PURCHASE)
for optField in ('support_url', 'homepage', 'is_offline'):
if optField in spec:
setattr(app, optField, spec[optField])
# Status has to be updated at the end because STATUS_DELETED apps can't
# be saved.
app.status = status
app.save()
for (region, region_status) in special_regions.iteritems():
app.geodata.update(**{'region_%s_nominated' % (region,):
datetime.datetime.now(),
'region_%s_status' % (region,):
STATUS_CHOICES_API_LOOKUP[region_status]})
if tarako:
AdditionalReview.objects.create(app=app, queue='tarako')
addon_review_aggregates(app.pk)
if rereview:
RereviewQueue.objects.get_or_create(addon=app)
try:
u = UserProfile.objects.get(email=developer_email)
except UserProfile.DoesNotExist:
u = create_user(developer_email)
u.display_name = developer_name
u.save()
AddonUser.objects.create(user=u, addon=app)
return app
class TestReference(Patcher, TestCase):
fixtures = fixture('user_999')
def setUp(self, *args, **kw):
super(TestReference, self).setUp(*args, **kw)
self.user = UserProfile.objects.get(pk=999)
self.ref = Reference()
def test_setup_seller(self):
self.ref.setup_seller(self.user)
ok_(SolitudeSeller.objects.filter(user=self.user).exists())
def test_account_create(self):
data = {'account_name': 'account', 'name': 'f', 'email': '*****@*****.**'}
res = self.ref.account_create(self.user, data)
acct = PaymentAccount.objects.get(user=self.user)
eq_(acct.provider, PROVIDER_REFERENCE)
eq_(res.pk, acct.pk)
def make_account(self):
seller = SolitudeSeller.objects.create(user=self.user)
return PaymentAccount.objects.create(user=self.user,
solitude_seller=seller,
uri='/f/b/1')
def test_terms_retrieve(self):
account = self.make_account()
self.ref.terms_retrieve(account)
assert self.ref_patcher.terms.called
def test_terms_update(self):
account = self.make_account()
self.ref.terms_update(account)
eq_(account.reload().agreed_tos, True)
assert self.ref_patcher.sellers.called
def test_account_retrieve(self):
account = self.make_account()
self.ref.account_retrieve(account)
assert self.ref_patcher.sellers.called
def test_account_update(self):
account = self.make_account()
self.ref.account_update(account, {'account_name': 'foo'})
eq_(account.reload().name, 'foo')
assert self.ref_patcher.sellers.called
def test_product_create_exists(self):
self.ref_patcher.products.get.return_value = [{'resource_uri': '/f'}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
# Product should have been got from zippy, but not created by a post.
assert self.ref_patcher.products.get.called
@raises(ValueError)
def test_product_mulitple(self):
self.ref_patcher.products.get.return_value = [{}, {}]
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
def test_product_create_not(self):
self.generic_patcher.product.get_object_or_404.return_value = {
'external_id': 'ext'
}
self.ref_patcher.products.get.return_value = []
self.ref_patcher.products.post.return_value = {'resource_uri': '/f'}
account = self.make_account()
app = app_factory()
self.ref.product_create(account, app)
self.ref_patcher.products.get.assert_called_with(seller_id='1',
external_id='ext')
self.ref_patcher.products.post.assert_called_with(
data={
'seller_id': '1',
'external_id': 'ext',
'name': unicode(app.name)
})
