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