def test_web_user_list_consignments(self):
from ...api import ConsignEndpoint
from ...models import Consignment
from ...serializers import OwnershipEditionSerializer
from util.util import ordered_dict
from dynamicfixtures import _djroot_user, _alice, _bob, _registered_edition_alice
_djroot_user()
alice = _alice()
bob = _bob()
edition_alice = _registered_edition_alice()
consignment = Consignment.create(edition_alice, consignee=bob, owner=alice)
consignment.save()
url = reverse('api:ownership:consignment-list')
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = ConsignEndpoint.as_view({'get': 'list'})
response = view(request)
qs = Consignment.objects.filter(Q(prev_owner=alice) | Q(new_owner=bob))
serializer = OwnershipEditionSerializer(qs, many=True, context={'request': request})
response_db = json.loads(json.dumps({'success': True,
'count': len(qs),
'unfiltered_count': len(qs),
'next': None,
'previous': None,
'consignments': serializer.data}))
self.assertEqual(ordered_dict(response.data), ordered_dict(response_db))
self.assertIs(response.status_code, status.HTTP_200_OK)
for consignment in response.data['consignments']:
self.assertIn('edition', consignment)
self.assertNotIn('piece', consignment)
def test_retrieve_prize(self):
from ..api import PrizeEndpoint
from dynamicfixtures import _alice, _prize_with_whitelabel
alice = _alice()
prize = _prize_with_whitelabel(subdomain='yellow')
url = reverse('api:prize:prize-detail',
kwargs={'pk': prize.subdomain})
view = PrizeEndpoint.as_view({'get': 'retrieve'})
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
response = view(request, pk=prize.subdomain)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('active_round', response.data)
self.assertIn('name', response.data)
self.assertIn('whitelabel_settings', response.data)
self.assertIn('rounds', response.data)
self.assertIn('active', response.data)
self.assertIn('subdomain', response.data)
self.assertIn('num_submissions', response.data)
self.assertEqual(response.data['active_round'], prize.active_round)
self.assertEqual(response.data['name'], prize.name)
self.assertEqual(response.data['whitelabel_settings'],
prize.whitelabel_settings.pk)
self.assertEqual(response.data['rounds'], prize.rounds)
self.assertEqual(response.data['active'], prize.active)
self.assertEqual(response.data['subdomain'], prize.subdomain)
self.assertEqual(response.data['num_submissions'],
prize.num_submissions)
def test_create_signature(self):
from dynamicfixtures import _alice
from s3.models import S3HttpRequest
from util.util import hash_string
alice = _alice()
self.client.login(username=alice.username, password='******')
url = reverse('s3:s3_sign')
filename = 'dummy.jpg'
key = 'local/{}/{}'.format(hash_string(str(alice.pk)), filename)
data = {
'conditions': [
{'acl': 'public-read'},
{'bucket': settings.AWS_STORAGE_BUCKET_NAME},
{'Content-Type': 'image/jpeg'},
{'success_action_status': '200'},
{'key': key},
{'x-amz-meta-qqfilename': filename},
['content-length-range', '0', settings.AWS_MAX_SIZE[0]],
],
}
self.assertFalse(S3HttpRequest.objects.exists())
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(S3HttpRequest.objects.exists())
s3_http_request = S3HttpRequest.objects.get()
self.assertEqual(
s3_http_request.path,
'/{}/{}'.format(settings.AWS_STORAGE_BUCKET_NAME, key),
)
def test_web_user_retrieve_loan(self):
from ...api import LoanEndpoint
from ...models import Loan
from ...serializers import LoanSerializer
from util.util import ordered_dict
from dynamicfixtures import _djroot_user, _alice, _bob, _registered_edition_alice
_djroot_user()
alice = _alice()
bob = _bob()
edition_alice = _registered_edition_alice()
loan = Loan.create(edition_alice, loanee=bob, owner=alice)
loan.save()
factory = APIRequestFactory()
url = reverse('api:ownership:loan-detail', kwargs={'pk': loan.pk})
request = factory.get(url)
force_authenticate(request, user=alice)
view = LoanEndpoint.as_view({'get': 'retrieve'})
response = view(request, pk=loan.pk)
serializer = LoanSerializer(loan, context={'request': request})
response_db = json.loads(json.dumps(serializer.data))
self.assertEqual(ordered_dict(response.data['loan']),
ordered_dict(response_db))
self.assertIs(response.status_code, status.HTTP_200_OK)
self.assertIn('edition', response.data['loan'])
self.assertNotIn('piece', response.data['loan'])
def test_subject_with_unicode(self):
from ..messages import OwnershipSenderEmailMessage
from dynamicfixtures import _alice, _edition_alice
alice = _alice()
edition = _edition_alice()
edition.parent.title = 'à'
message = OwnershipSenderEmailMessage(sender=alice,
editions=(edition, ))
message.send()
self.assertEqual(len(mail.outbox), 1)
def test_override_subdomain_lumenus(self):
from ..messages import TransferEmailMessageLumenus
from dynamicfixtures import _alice, _bob, _edition_alice
alice = _alice()
bob = _bob()
edition = _edition_alice()
message = TransferEmailMessageLumenus(sender=alice,
receiver=bob,
editions=(edition, ),
subdomain='lumenus')
parsed_url = urlparse(message.redirect_url)
self.assertEqual(parsed_url.netloc.split('.')[0], 'www')
def test_sign_url_with_authenticated(self):
from s3.views import sign_url
from dynamicfixtures import _alice, _piece_alice
alice = _alice()
piece = _piece_alice()
url = reverse('s3:sign_url')
url += '?key={}&title={}&artist_name={}'.format(piece.digital_work.key, piece.title, piece.artist_name)
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
response = sign_url(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_retrieve_coa(self):
from ..api import CoaEndpoint
from dynamicfixtures import _alice
from ..models import CoaFile
alice = _alice()
coa_obj = CoaFile.objects.create(user=alice, coa_file='dummy.txt')
url = reverse('api:coa:coafile-detail', kwargs={'pk': coa_obj.pk})
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = CoaEndpoint.as_view({'get': 'retrieve'})
response = view(request, pk=coa_obj.pk)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_with_no_coa(self):
from ..api import CoaEndpoint
from dynamicfixtures import _alice
alice = _alice()
url = reverse('api:coa:coafile-list')
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = CoaEndpoint.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('coas', response.data)
self.assertListEqual(response.data['coas'], [])
def test_deserialization_without_message(self):
from ..serializers import SharePieceModalForm
from dynamicfixtures import _alice, _bob, _piece
alice = _alice()
bob = _bob()
piece = _piece()
data = {'share_emails': bob.email, 'piece_id': piece.pk}
request = HttpRequest()
request.user = alice
serializer = SharePieceModalForm(data=data,
context={'request': request})
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data['share_message'], '')
def test_list_with_one_coa_not_belonging_to_requesting_user(self):
from ..api import CoaEndpoint
from ..models import CoaFile
from dynamicfixtures import _alice, _bob
alice, bob = _alice(), _bob()
CoaFile.objects.create(user=bob)
url = reverse('api:coa:coafile-list')
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = CoaEndpoint.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('coas', response.data)
self.assertListEqual(response.data['coas'], [])
def test_verfiy_coa_with_authentication(self):
from ..api import CoaEndpoint
from ..models import generate_crypto_message
from dynamicfixtures import _alice, _registered_edition_alice
edition = _registered_edition_alice()
alice = _alice()
url = reverse('api:coa:coafile-verify-coa')
message, _, signature = generate_crypto_message(edition)
data = {'message': message, 'signature': signature}
request = APIRequestFactory().post(url, data, format='json')
force_authenticate(request, user=alice)
view = CoaEndpoint.as_view({'post': 'verify_coa'},
**CoaEndpoint.verify_coa.kwargs)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_prizes(self):
from ..api import PrizeEndpoint
from dynamicfixtures import _alice, _prize_with_whitelabel
alice = _alice()
_prize_with_whitelabel(subdomain='yellow')
_prize_with_whitelabel(subdomain='green')
url = reverse('api:prize:prize-list')
view = PrizeEndpoint.as_view({'get': 'list'})
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
subdomains = [prize['subdomain'] for prize in response.data['results']]
self.assertIn('yellow', subdomains)
self.assertIn('green', subdomains)
def test_create_key_with_piece_id(self):
from s3.views import create_key
from dynamicfixtures import _alice, _piece_alice
alice = _alice()
piece = _piece_alice()
post_data = {
'filename': 'dummy.jpg',
'category': 'thumbnail',
'piece_id': piece.pk,
'uuid': '7aeaadeb-6ece-4a53-889d-114924ec5bb9',
}
url = reverse('s3:key')
factory = APIRequestFactory()
request = factory.post(url, post_data, format='json')
force_authenticate(request, user=alice)
response = create_key(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.content_type, 'application/json')
self.assertIn('key', response.data)
self.assertIn('/dummmy/thumbnail/', response.data['key'])
def test_retrieve_non_existant_registration(self):
"""
The goal of this test is to verify that a 404 (not found) is returned
upon attempting to retrieve a registration that does not eixit.
"""
from ..api import RegistrationEndpoint
from ..models import OwnershipRegistration
from dynamicfixtures import _alice
alice = _alice()
pk = 1
self.assertFalse(OwnershipRegistration.objects.filter(pk=pk).exists())
url = reverse('api:ownership:ownershipregistration-detail',
kwargs={'pk': pk})
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = RegistrationEndpoint.as_view({'get': 'retrieve'})
response = view(request, pk=pk)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_create_loan_edition(self):
from ...api import LoanEndpoint
from ...models import Loan
from dynamicfixtures import _djroot_user, _alice, _bob, _registered_edition_alice
password = '******'
_djroot_user()
alice = _alice()
bob = _bob()
edition_alice = _registered_edition_alice()
data = {
'loanee': bob.email,
'bitcoin_id': edition_alice,
'startdate': datetime.utcnow().date(),
'enddate': datetime.utcnow().date() + timedelta(days=1),
'password': password,
'terms': True
}
view = LoanEndpoint.as_view({'post': 'create'})
factory = APIRequestFactory()
url = reverse('api:ownership:loan-list')
request = factory.post(url, data)
force_authenticate(request, user=alice)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# check that the loan exists
loans = Loan.objects.filter(edition=edition_alice)
self.assertEqual(len(loans), 1)
loan = loans[0]
# check owners
self.assertEqual(loan.prev_owner, alice)
self.assertEqual(loan.new_owner, bob)
# check the status is None (meaning unconfirmed)
self.assertIsNone(loan.status)
self.assertIn('loan', response.data)
self.assertIn('edition', response.data['loan'])
def test_list_with_one_coa_belonging_to_requesting_user(self):
from ..api import CoaEndpoint
from ..models import CoaFile
from dynamicfixtures import _alice
alice = _alice()
coa_obj = CoaFile.objects.create(user=alice, coa_file='dummy.txt')
url = reverse('api:coa:coafile-list')
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
view = CoaEndpoint.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('coas', response.data)
self.assertEqual(len(response.data['coas']), 1)
coa_data = response.data['coas'][0]
self.assertIn('coa_file', coa_data)
self.assertIn('url', coa_data)
self.assertIn('url_safe', coa_data)
self.assertEqual(coa_data['coa_file'], coa_obj.coa_file)
self.assertEqual(coa_data['url'], coa_obj.url)
self.assertEqual(coa_data['url_safe'], coa_obj.url_safe)
def test_create_prize_piece(self):
from dynamicfixtures import (
_djroot_user,
_djroot_bitcoin_wallet,
_alice,
_alice_bitcoin_wallet,
_license,
_digital_work_alice,
_prize_with_whitelabel,
)
from ..api import PrizePieceEndpoint
subdomain = 'portfolioreview'
_djroot_user()
_djroot_bitcoin_wallet()
alice = _alice()
_alice_bitcoin_wallet()
license = _license()
digital_work = _digital_work_alice()
_prize_with_whitelabel(subdomain=subdomain)
data = {
'prize_name': subdomain,
'terms': True,
'digital_work_key': digital_work.key,
'artist_name': 'alice',
'title': 'green stars',
'license': license.code,
}
url = reverse('api:prize:prize-pieces-list',
kwargs={'domain_pk': subdomain})
view = PrizePieceEndpoint.as_view({'post': 'create'})
factory = APIRequestFactory()
headers = {
'HTTP_ORIGIN': 'http://{}.ascribe.test'.format(subdomain),
}
request = factory.post(url, data=data, **headers)
force_authenticate(request, user=alice)
response = view(request, domain_pk=subdomain)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_update_prize_with_new_round(self):
from ..api import PrizeEndpoint
from ..models import Prize, PrizeUser
from dynamicfixtures import (
_alice, _prize_with_whitelabel, _prize_judge, _prize_juror)
alice = _alice()
prize = _prize_with_whitelabel(subdomain='yellow')
prize.rounds = 3
prize.save()
judge = _prize_judge(subdomain='yellow')
juror = _prize_juror(subdomain='yellow')
data = {
'active_round': 2,
'name': 'yellow',
'rounds': 3,
'active': False,
'subdomain': 'yellow',
'num_submissions': None,
}
url = reverse('api:prize:prize-detail',
kwargs={'pk': prize.pk})
view = PrizeEndpoint.as_view({'put': 'update'})
factory = APIRequestFactory()
request = factory.put(url, data=data, format='json')
force_authenticate(request, user=alice)
self.assertEqual(prize.active_round, 1)
self.assertTrue(judge.is_judge)
self.assertTrue(juror.is_jury)
response = view(request, pk=prize.pk)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['active_round'], 2)
self.assertEqual(Prize.objects.get(pk=prize.pk).active_round, 2)
judge = PrizeUser.objects.get(pk=judge.pk)
self.assertFalse(judge.is_judge)
self.assertFalse(judge.is_jury)
juror = PrizeUser.objects.get(pk=juror.pk)
self.assertFalse(juror.is_jury)
self.assertFalse(juror.is_judge)
def test_acl_edit_of_a_retrieved_transferred_edition(self):
from dynamicfixtures import (
_djroot_user,
_alice,
_bob,
_bob_bitcoin_wallet,
_registered_edition_pair_alice,
_whitelabel_merlin,
)
from bitcoin import tasks
from bitcoin.models import BitcoinTransaction, BitcoinWallet
from ownership.models import OwnershipRegistration, OwnershipTransfer
from util import util
_djroot_user()
alice, bob = _alice(), _bob()
_bob_bitcoin_wallet()
edition_one, edition_two = _registered_edition_pair_alice()
# TODO Extract, and/or simplify to the essentials.
#
# What are the essentials?
# - Having two editions.
# - The two editions belong to the same piece.
# - The piece has been registered by alice.
# - One edition has been transferred to bob.
# - The transferred edition should have its acl_edit set accordingly.
#
# So, it may very well be possible to avoid going through all the
# transfer related operations. Waht matters is that the transferred
# edition has its fields set like it would have if it would have been
# transferred. Related objects, which are created and/or modified
# during a transfer may alos need to be created.
OwnershipRegistration.objects.create(
edition=edition_one,
new_owner=edition_one.owner,
piece=edition_one.parent,
type=OwnershipRegistration.__name__,
)
transfer = OwnershipTransfer(
edition=edition_one,
prev_owner=edition_one.owner,
new_owner=bob,
prev_btc_address=None,
piece=edition_one.parent,
type=OwnershipTransfer.__name__,
)
transfer.ciphertext_wif = BitcoinWallet.encoded_wif_for_path(
transfer,
'alice-secret',
)
transfer.save()
transfer_tx = BitcoinTransaction.transfer(transfer)
refill = BitcoinTransaction.refill(transfer)
refill.dependent_tx = transfer_tx
refill.save()
tasks.refill(refill.id, util.mainAdminPassword())
edition_one.owner = bob
edition_one.save()
# END of transfer
whitelabel = _whitelabel_merlin()
subdomain = whitelabel.subdomain
view = MarketEditionEndpoint.as_view({'get': 'retrieve'})
url = reverse(
'api:whitelabel:market:edition-detail',
kwargs={'domain_pk': subdomain, 'pk': edition_two.bitcoin_id},
)
factory = APIRequestFactory()
request = factory.get(url)
force_authenticate(request, user=alice)
response = view(
request, pk=edition_two.bitcoin_id, domain_pk=subdomain)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertFalse(response.data['edition']['acl']['acl_edit'])
self.assertTrue(response.data['edition']['acl']['acl_wallet_submit'])
